How to Install Git on Ubuntu and Manage Your Coding Projects

Introduction

Software development involves more than writing code. As a project grows, developers need a reliable way to track changes, recover earlier versions, experiment with new features, and collaborate with other programmers. Without a suitable version-control system, even a small application can become difficult to maintain. This is where Git becomes an essential tool for programming on Ubuntu.

Git is a free, open-source distributed version-control system used by developers around the world. It records changes to files over time, allowing you to review your development history, create separate branches for new features, and combine work from different contributors. It works with almost any programming language and can manage projects ranging from small Bash scripts to large software applications.

Ubuntu provides a convenient environment for using Git because the operating system includes a powerful terminal and a package manager that simplifies software installation. You can install Git in a few commands and begin tracking a project without purchasing additional software.

Git is also commonly used with online hosting platforms such as GitHub, GitLab, and Bitbucket. These platforms allow developers to store remote repositories, review contributions, collaborate on code, and maintain backups of their development history. However, Git itself works locally and does not require an internet connection for basic version-control operations.

In this comprehensive tutorial, you will learn how to install Git on Ubuntu, configure your identity, create your first repository, track files, make commits, work with branches, undo common mistakes, connect to a remote repository, and follow security best practices.

Whether you are a beginner learning Python or an experienced developer maintaining applications, understanding Git can make your programming workflow more organized and reliable.

1. What Is Git and Why Do Developers Use It?

Git is a distributed version-control system designed to record and manage changes to files.

Imagine that you are developing a Python application. You write the initial program, add several features, fix bugs, and eventually discover that a recent change has broken something that previously worked.

Without version control, you might have to create multiple copies of the project manually. These copies can become confusing because filenames such as project-final, project-final-new, and project-final-fixed do not provide a dependable history of what changed.

Git offers a more structured solution.

You create a repository and save meaningful snapshots of your work through commits. Each commit records a project state along with metadata such as the author, timestamp, and commit message.

You can then examine previous commits, compare changes, create branches, and return to earlier versions when necessary.

Git provides several important benefits:

Change tracking: Records changes to tracked files over time.

History inspection: Allows you to review previous commits and understand how a project evolved.

Branching: Lets you develop features separately from the main line of work.

Collaboration: Helps multiple developers exchange and combine changes.

Recovery: Provides ways to restore files or undo particular changes.

Offline development: Supports local commits and many other operations without an internet connection.

Remote integration: Works with hosting platforms that store repositories online.

Git is useful even when you work alone. A personal project can benefit from a clear history, particularly when you experiment with unfamiliar libraries or make substantial changes to existing code.

For example, if you maintain an Ubuntu automation script, you can use Git to record its initial version, add logging in a later commit, and introduce error handling in another. If a new change creates a problem, you can inspect the history to understand what happened.

Learning Git early will help you develop habits that are valuable across almost every software-development field.

2. Check Whether Git Is Already Installed on Ubuntu

Before installing Git, check whether it is available on your computer.

Open the terminal by pressing Ctrl + Alt + T.

Run the following command:

git --version

If Git is installed, the terminal displays a version number similar to:

git version 2.x.x

The exact version depends on your Ubuntu release and installation method.

You can also check the executable's location:

command -v git

On a typical Ubuntu installation, the command returns a path such as:

/usr/bin/git

If Git is already installed, you do not necessarily need to reinstall it. You can move directly to the configuration section.

If the terminal reports that the command is unavailable, continue with the installation procedure.

Checking the existing installation first prevents unnecessary software changes and helps you identify which Git executable your terminal is using.

This is especially useful when you have installed development tools through multiple methods or use a customized shell environment.

3. Install Git on Ubuntu Using APT

The simplest installation method for most Ubuntu users is the APT package manager.

APT installs software from configured repositories and manages the dependencies required by the packages.

First, refresh the local package index:

sudo apt update

This command downloads current package information from your configured Ubuntu repositories.

Next, install Git:

sudo apt install git

Review the proposed package changes and confirm the installation when prompted.

After the process finishes, verify the installation:

git --version

You should now see the installed Git version.

If you also want Git's documentation and manual pages, Ubuntu may provide additional documentation packages. These are optional for basic usage.

For most beginners, the standard Git package is sufficient.

Why Use Ubuntu's Package Manager?

Installing Git through APT offers several advantages:

It uses Ubuntu's configured package repositories.

It manages required dependencies.

It integrates with the operating system's package-management workflow.

It simplifies receiving supported package updates.

It avoids the need to compile Git from source.

The available version depends on your Ubuntu release and configured repositories. If you specifically need a newer release than the repository provides, review the official Git documentation and select an installation method appropriate for your system.

Avoid adding unknown software repositories just to obtain a newer version. Every additional repository creates another source of software that you must trust and maintain.

4. Configure Your Git Username and Email

After installation, configure the identity Git should record in your commits.

Open the terminal and run:

git config --global user.name "Your Name"

git config --global user.email "you@example.com"

Replace the example values with your preferred commit identity.

For example, a developer might configure:

git config --global user.name "Alex Developer"

git config --global user.email "alex@example.com"

These settings are stored in your global Git configuration and apply to repositories for your user account unless a repository overrides them.

The name and email identify the author information recorded in new commits. They are not necessarily your login credentials for GitHub or another hosting service.

If you use a hosting platform, consider which email address you want associated with your public contributions. Some platforms provide a privacy-preserving email address for commit attribution.

You can inspect your global settings with:

git config --global --list

To view the configured username alone, run:

git config --global user.name

To view the email address, run:

git config --global user.email

If you need a different identity for one project, navigate to that repository and configure local values:

git config user.name "Work Identity"

git config user.email "work@example.com"

Repository-specific settings override the corresponding global values for that repository.

Correct identity configuration is important when working with teams, maintaining public projects, or managing separate personal and professional repositories.

5. Create Your First Git Repository

Now that Git is installed and configured, create a small project and initialize version control.

Create a directory:

mkdir -p ~/projects/git-demo

cd ~/projects/git-demo

Create a Python file:

nano hello.py

Enter this code:

def main():

    print("Hello from Ubuntu!")

    print("This project is tracked with Git.")

if __name__ == "__main__":

    main()

Save the file and exit the editor.

Next, initialize a Git repository:

git init

Git creates the repository metadata needed to track changes in the directory.

Depending on your Git version and configuration, the command may display a message indicating that the initial branch is named master or another default name.

For new projects, many developers prefer the branch name main. You can explicitly rename the current branch:

git branch -M main

This command renames the current branch to main.

Now inspect the repository:

git status

Git should identify hello.py as an untracked file.

An untracked file exists in your working directory but has not yet been added to Git's tracking index.

This is normal. Git does not automatically track every file in a newly initialized repository.

You decide which files to include by staging them and recording commits.

Initializing a repository does not upload your code anywhere. At this stage, your repository is stored locally on your Ubuntu computer.

6. Track Files and Create Your First Commit

A Git commit records a snapshot of the project's tracked content.

Before making a commit, you normally stage the changes you want to include.

In your project directory, run:

git add hello.py

This stages the Python file.

Now check the repository status:

git status

The file should appear as a new file staged for the next commit.

Create your first commit:

git commit -m "Add initial Python program"

Git records the staged content and associates it with a commit message.

A commit message should briefly explain the change.

Examples include:

Add initial Python program

Fix input validation

Improve error handling

Add installation instructions

Update project documentation

Good commit messages help you understand the purpose of changes when you inspect the history later.

After committing, run:

git status

If no additional changes have been made, Git should report that the working tree is clean.

This means there are no uncommitted changes to tracked files and no untracked files that Git is reporting in that working directory.

You can now modify the Python file, stage your changes, and create another commit.

For example, add another print statement to hello.py, save it, and run:

git add hello.py

git commit -m "Add another program message"

Your repository now contains a history of at least two commits.

This is the basic cycle of Git development: edit files, inspect changes, stage the intended changes, and commit them with meaningful messages.

7. Understand the Git Working Tree, Staging Area, and Repository

Understanding Git's three main areas makes everyday commands easier to use.

Working Tree

The working tree contains the files and directories you see and edit in your project.

When you modify hello.py, the changes first exist in your working tree.

Git can compare those changes with the last committed version.

Staging Area

The staging area records which changes you intend to include in your next commit.

You can stage a complete file:

git add hello.py

Or stage all changes in the current directory and its subdirectories:

git add .

The second command can include untracked files, so inspect the resulting staged changes before committing.

For more precise control, stage individual files or use interactive staging when you need to select specific portions of a file.

Repository History

The repository history contains commits that record previous project states.

You can inspect the history with:

git log

For a compact view, use:

git log --oneline

To inspect the changes introduced by the latest commit, run:

git show --stat HEAD

The HEAD reference usually points to the currently checked-out commit.

These three areas work together. You edit files in the working tree, select changes in the staging area, and create a commit that records the staged snapshot.

This separation is one of Git's most useful features because it allows you to work on several changes while choosing exactly what belongs in a particular commit.

For example, you might fix a small bug and begin a larger feature in the same file. Interactive staging can help you commit the bug fix separately from the unfinished feature.

8. Check Changes Before Committing

Before recording changes, inspect what you have modified.

Suppose you edit hello.py and add another message.

Run:

git status

Git displays the files that have changed.

To view unstaged modifications, use:

git diff

This command compares the working-tree changes with the current staging area.

After staging a file, inspect the staged changes with:

git diff --staged

This shows what will be included in the next commit.

Reviewing the diff helps you catch mistakes such as accidental deletions, unrelated edits, debugging output, or sensitive information.

If you discover a problem before staging, you can edit the file and correct it.

If you have already staged a file but do not want those changes included, unstage it with:

git restore --staged hello.py

This removes the file's changes from the staging area without discarding the modifications in your working tree.

You can then make further edits and stage the intended changes again.

For beginners, it is a good habit to run git status and inspect the diff before important commits.

This small step can prevent accidental changes from entering the project history and makes the repository easier to maintain.

9. Create and Manage Git Branches

Branches let you work on new features or experiments separately from the main development line.

Suppose your Python project works correctly and you want to add a feature. Instead of changing the main branch immediately, create a feature branch.

Run:

git switch -c add-greeting

This creates a new branch named add-greeting and switches to it.

Make a change to hello.py, such as adding a function that formats a greeting.

Stage and commit the change:

git add hello.py

git commit -m "Add greeting functionality"

The commit is now part of the feature branch.

To list local branches, run:

git branch

The current branch is marked with an asterisk.

To return to the main branch, use:

git switch main

The working tree now reflects the version associated with the main branch.

If the feature branch contains changes that you want to integrate, you can merge it into the main branch:

git merge add-greeting

Run the merge from the branch that should receive the changes. In this example, that is main.

If the changes can be combined automatically, Git completes the merge. If conflicts occur, Git asks you to resolve them before completing the operation.

Branches are useful for adding features, fixing bugs, testing ideas, and collaborating with other developers.

For small personal projects, you may not need many branches. For larger projects, a branch-based workflow can help keep unfinished work separate from stable code.

After a branch has been merged and is no longer needed, you can delete it:

git branch -d add-greeting

Git may refuse to delete a branch if it contains changes that have not been merged. Pay attention to this warning rather than forcing deletion without understanding the consequences.

10. Undo Changes Safely with Git

One of Git's most valuable features is its ability to help recover from mistakes. However, different commands affect different areas of your repository, so you should understand their behavior before using them.

Discard Unstaged Changes to a File

If you want to discard working-tree changes to a tracked file and restore it to the version in the index, use:

git restore hello.py

This can permanently discard modifications that exist only in the working tree.

Make sure you do not need those changes before running the command.

Unstage a File

If you staged a file by mistake, run:

git restore --staged hello.py

This unstages the file but keeps your working-tree modifications.

Create a New Commit That Reverses an Earlier Commit

If an earlier commit introduced a mistake, git revert can create a new commit that reverses the changes made by that commit:

git revert COMMIT_ID

Replace COMMIT_ID with the relevant commit hash.

This approach is often suitable for shared branches because it preserves the existing history.

Move the Current Branch Backward

The git reset command can move the current branch reference and change the staging area or working tree depending on the options used.

For example:

git reset --soft HEAD~1

This moves the current branch back one commit while keeping the reverted commit's changes staged.

By contrast, commands that use --hard can discard uncommitted changes and reset tracked files to a selected state.

Do not use git reset --hard casually, particularly if you have uncommitted work.

Before performing a destructive operation, inspect your status and consider creating a backup branch or another safe copy of important work.

Git provides powerful recovery tools, but understanding their effects is essential for using them responsibly.

11. Connect Your Ubuntu Repository to GitHub

GitHub is an online platform for hosting Git repositories and collaborating on software projects.

Git and GitHub are not the same thing. Git manages version history, while GitHub provides remote repository hosting and additional collaboration features.

To publish your local repository, first create an empty repository through your Git hosting account.

Choose a repository name, such as ubuntu-git-demo.

If you already have a local project with commits, creating the remote repository without automatically generating a README, license, or initial commit can simplify the first push.

After creating the repository, copy its remote URL from the hosting platform.

For an HTTPS remote, the URL commonly follows this pattern:

https://github.com/USERNAME/ubuntu-git-demo.git

Replace USERNAME with the appropriate account name and use the actual URL supplied by your hosting platform.

Inside your local project, add the remote:

git remote add origin https://github.com/USERNAME/ubuntu-git-demo.git

Check the configured remote:

git remote