Within the realm of software creation, version management plays a crucial role in sustaining a well-structured and streamlined project progression. This enables developers to monitor modifications to their code, cooperate effortlessly, and revert to earlier versions as needed.

Among the widely favored version control systems is Git, which, when integrated with the internet-based platform GitHub, transforms into a vital instrument for every developer operating on Linux.

In this blog article, I will explore the methodology of deploying version management through the utilization of Git and GitHub within a Linux setting.

Our discussion will encompass the fundamentals of Git, the merits of employing GitHub, and supply a detailed, step-by-step tutorial on establishing and leveraging these resources to enhance your project’s workflow.

Understanding Git

Git is a distributed version control system (DVCS) that allows developers to maintain a local repository with a complete history of their project.

Unlike a centralized version control system – Git doesn’t require a constant connection to a central server. Instead, each developer will work with a local copy of the project – which they can push and pull from the remote repository as needed.

Some of the key benefits of using Git are:

  1. Efficiency: Git is incredibly fast – making it easy to manage large projects and complex codebases.
  2. Branching and merging: Git’s branching model allows developers to work on multiple features or bug fixes simultaneously – merging them back into the main codebase when they’re ready.
  3. Collaboration: Git’s distributed nature makes it simple for developers to collaborate on projects – merging their changes with minimal conflicts.
  4. Security: Git uses cryptographic methods to ensure the integrity of your project’s history – ensuring that the data is protected from tampering or corruption.

Leveraging GitHub

GitHub is a web-based platform that provides a user-friendly interface for hosting and managing Git repositories.

With GitHub, developers can collaborate on projects, submit and review code changes, and manage project issues and milestones. Some of the advantages of using GitHub include:

  1. Access control: GitHub allows you to manage who has access to your repository, giving you control over who can view, edit, and push changes to your project.
  2. Integration: GitHub integrates with numerous tools and services, making it easy to streamline your project’s workflow.
  3. Issue tracking: GitHub’s built-in issue tracking system allows you to manage bugs, feature requests, and other project-related tasks.
  4. Community: With millions of users worldwide, GitHub’s community is a valuable resource for learning, networking, and sharing code.

Setting Up Git and GitHub on Linux

Now that you have a basic understanding of Git and GitHub, let’s dive into setting up these tools for handling version control on Linux with Git and GitHub on your Linux machine.

  1. Installing Git

To install Git on your Linux system, open your terminal and run the following command, depending on your distribution:

  • For Debian-based distributions (e.g., Ubuntu, Linux Mint):
sudo apt-get update
sudo apt-get install git
  • For Red Hat-based distributions (e.g., CentOS, Fedora):
sudo yum install git
  • For Arch-based distributions (e.g., Manjaro, Antergos):
sudo pacman -S git

After installing Git, verify the installation by typing git --version in your terminal. If Git is installed correctly, you should see its version number.

  1. Configuring Git

Before using Git, it’s essential to configure your user information, which will be used in your commits. Run the following commands to set your name and email address:

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

You can check your Git configuration by running git config --list.

  1. Creating a GitHub Account

To create a GitHub account, visit https://github.com/ and click on “Sign up.” Provide a username, email address, and password, then follow the on-screen instructions to complete the registration process. Once you’ve successfully created your account, sign in to access your GitHub dashboard.

  1. Generating an SSH Key Pair

To securely connect your local Git repository with your GitHub account, you need to generate an SSH key pair. In your terminal, run the following command:

ssh-keygen -t ed25519 -C "youremail@example.com"

Follow the on-screen prompts to complete the process. By default, the key pair will be stored in the ~/.ssh directory.

  1. Adding the SSH Key to GitHub

To add the SSH key to your GitHub account, first copy the contents of the public key file by running:

cat ~/.ssh/id_ed25519.pub 

Next, go to the GitHub website, click on your profile picture in the top-right corner, and select “Settings.” In the left sidebar, click on “SSH and GPG keys,” then click the “New SSH key” button. Paste the contents of your public key into the “Key” field, give it a descriptive title, and click “Add SSH key.”

  1. Creating a Repository

To create a new repository on GitHub, click on the “+” icon in the top-right corner and select “New repository.” Provide a name for your repository, add a description (optional), choose whether to make it public or private, and decide if you want to initialize it with a README file. Once you’ve made your selections, click “Create repository.”

  1. Cloning the Repository

To clone the newly created repository to your local machine, open your terminal, navigate to the directory where you want to store your project, and run:

git clone git@github.com:YourUsername/YourRepository.git

Replace YourUsername and YourRepository with your GitHub username and the name of your repository, respectively. This command will create a new directory containing the repository’s contents.

  1. Making Changes and Committing

To make changes to your project, open the files using your preferred text editor or IDE. After making the necessary edits, you can stage the changes using the following command:

git add .

The . indicates that you want to stage all modified files. Alternatively, you can specify individual files by replacing the . with the file names.

Once your changes are staged, commit them with a descriptive message:

git commit -m "A meaningful commit message"
  1. Pushing Changes to GitHub

To push your local commits to the remote repository on GitHub, run the following command:

git push origin main

Replace main with the name of the branch you want to push to (e.g., master or any other branch you have created). If this is the first time you’re pushing changes to the repository, you may need to set the upstream branch with the following command:

git push --set-upstream origin main

  1. Pulling Changes from GitHub

When collaborating with others, you may need to fetch the latest changes from the remote repository and merge them with your local copy. To do this, run:

git pull origin main

Again, replace main with the name of the branch you want to pull from.

  1. Branching and Merging

Git’s powerful branching feature allows you to work on multiple features or bug fixes simultaneously without affecting the main codebase. To create a new branch, run:

git checkout -b feature/my-feature

Replace my-feature with a descriptive name for your new branch. This command creates a new branch and switches to it automatically.

To switch between branches, use the git checkout command followed by the branch name:

git checkout main

Once you’ve completed the work on your feature branch and want to merge it into the main branch, ensure you’ve switched to the main branch and run:

git merge feature/my-feature

This will merge your feature branch into the main branch. If there are any conflicts during the merge, Git will prompt you to resolve them before the merge can be completed.

  1. Collaborating with Pull Requests

Pull requests are a crucial aspect of collaboration on GitHub. They allow you to propose changes to a project, discuss them with other contributors, and merge them when they’re ready.

To create a pull request, push your changes to a branch on your remote repository, then navigate to the repository’s main page on GitHub. Click the “Pull Requests” tab, followed by the “New Pull Request” button.

Select the base branch (the one you want to merge your changes into) and the compare branch (the one containing your changes). Review the changes and click “Create Pull Request.”

Project maintainers will review your pull request, discuss any necessary modifications, and merge it when it’s ready.


Establishing version management on Linux using Git and GitHub can greatly enhance your software development workflow.

These tools allow you to efficiently manage and collaborate on projects, track changes, and revert to previous versions when necessary. By following this comprehensive guide

Related topics:

Exploring Linux Gaming with Steam Proton and Lutris: The Ultimate Guide

Building a Robust Linux-based Mail Server with Postfix and Dovecot

Managing multiple Linux distributions with boot loaders

Top Linux Backup Solutions for Home Users: A Comprehensive Guide

Windows Software on Linux with Wine

Categories: LinuxBlog

James R. Kinley - It Admin

James R. Kindly

My Name is James R. Kindly i am the founder and primary author of Storaclix, a website dedicated to providing valuable resources and insights on Linux administration, Oracle administration, and Storage. With over 20 years of experience as a Linux and Oracle database administrator, i have accumulated extensive knowledge and expertise in managing complex IT infrastructures and databases.

Save 30% on Apple AirPods Pro

Get the coolest AirPods ever released for:  $179,99  instead $249

  • Active Noise Cancellation blocks outside noise
  • Transparency mode for hearing and interacting with the world around you
  • Spatial audio with dynamic head tracking places sound all around you