The importance of Git (a version control software)

I consider Git the most essential software ever created for software development. Git is a version control software. If you have ever used the version history feature in Google Docs, you have already experienced version control software in action.

Git was created by Linus Torvalds in 2005 out of necessity while working on the Linux kernel (a software). Linux kernel is an open-source project, many individual software developers contribute code to the project codebase. To reliably track and merge all the codes, version control software was needed.

Most software is often created by a team of developers, where each developer works on different features of the software. Eventually, all these feature codes from individual developers are merged into a central codebase. Finally, it is packaged into a software product.

Imagine hundreds of developers contributing code to a codebase, without a tool to track and merge these changes correctly to the final codebase it will lead to unintended code loss overwriting each other's code in the final codebase and ultimately to bugs and often software errors.

I have worked in multiple startups and I have noticed that junior developers often neglect to learn Git when starting a new project thinking the Git tool is complicated, which is not.

Even some senior developers use Git just because the project lead told them to. I recalled my memory from one of the startups I worked for. I noticed that all the commit messages in the Git repository only had the text "save." No meaningful message was given to the commits by the senior developers, and all of them were working on the main branch.

A commit in Git can be described as a "save point" for a project. It records the changes made at a specific point in time, along with a message that explains the purpose of those changes.

It is useful when reverting to the earlier "save point", or simply to let other developers know what this commit is about without them checking each commit changes one by one (a commit can contain hundreds or thousands of changes).

Git is easy to learn, and its commands are intuitive. Some basics:

1. Repositories

• A repository (or repo) is a storage space where your project files and their history of changes are kept.
• Repositories can be local (on your computer) or remote (on platforms like GitHub).

2. Branches

• A branch is like a parallel workspace where you can develop features or fix bugs without impacting the main codebase.
• The default branch is often called main or master.
• You can create new branches (git branch branch_name) and switch between them (git checkout branch_name).

3. Merging

• When you're done working on a branch, you can merge it back into the main branch using git merge branch_name.

4. Key Commands

• git init: Initializes a new Git repository in your project folder.
• git add: Stages changes, marking them for inclusion in the next commit.
• git commit: Saves staged changes to the repository's history with a message describing the changes.
• git status: Shows the current state of your repository, including modified or staged files.
• git push: Sends your local commits to a remote repository.
• git pull: Fetches and integrates changes from a remote repository into your local repo.

Graphical User Interfaces (GUIs)

Apart from the command-line interface, there are user-friendly Git tools like:

• Sourcetree (⭐ My daily driver)
• GitHub Desktop
• GitKraken (Cool UI)
• Visual Studio Code's Git integration

These are all you need to know to use Git effectively.

If you're a software developer, learn Git.

Thank me later.

Pro Tip: Git is not limited to only software development.🤠