Git: The Version Control

What is Git?

Git is an open-source version control system created by Linus Torvalds in 2005. Unlike centralized version control systems, Git is distributed, meaning every developer has a complete copy of the repository history. This architecture enhances collaboration, speeds up operations, and ensures redundancy.

Git is a distributed version control system that tracks file changes and facilitates collaboration among multiple developers working on the same project.

Unlike centralized version control systems, which rely on a single, central repository to store project history, Git operates on a distributed model, allowing users to maintain a complete copy of the repository on their local machine.

Key Concepts:

1. Repository: At the heart of Git is the repository, or repo for short. A repository is essentially a directory or folder containing all a project's files, folders, and historical snapshots. Each developer working on a project has a copy of the repository, enabling them to work independently and make changes without affecting others.
2. Branches: Git uses branches to isolate work on different features, bug fixes, or experiments within a project. Each branch represents an independent line of development and can be created, merged, and deleted as needed. Branches provide a flexible way for developers to collaborate on a project without interfering with each other’s work.
3. Commits: In Git, changes to files are organised into commits. A commit represents a snapshot of the project at a specific point in time and includes a unique identifier, a commit message describing the changes, and a reference to the parent commit(s). Commits provide a detailed history of all changes made to the project, allowing developers to track the evolution of the codebase over time.
4. Merges: When work on a branch is complete, changes can be merged back into the main branch (usually the main branch) using a merge operation. Git intelligently combines the changes from one branch with those in another, preserving the history and integrity of the project. Merges are essential for integrating new features, resolving conflicts, and keeping the project codebase up-to-date.

In essence, Git empowers developers to work collaboratively, experiment freely, and iterate rapidly on codebases of any size or complexity. By understanding the core concepts of repositories, commits, branches, and merges, developers can leverage Git to manage project versions effectively, streamline workflows, and ensure the integrity and reliability of their code.

Setting Up Git

Before you start using Git, you need to install and configure it.

Installation

• Windows: Download the Git installer from git-scm.com, run it, and follow the prompts.
• macOS: Install Git using Homebrew.

brew install git        

• Linux: Install Git via your distribution’s package manager.

sudo apt-get install git # Debian/Ubuntu 
sudo yum install git # CentOS/RHEL        

Configuration

After installing Git, configure your identity with the following commands:

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

Basic Git Commands

Here are some essential commands to get you started:

Initializing a Repository

To create a new Git repository, navigate to your project directory and run:

git init        

Cloning a Repository

To clone an existing repository:

git clone <repository-url>        

Staging and Committing Changes

Add files to the staging area and commit them to the repository:

git add <file> 
git commit -m "Commit message"        

Viewing Changes

To see the status of your working directory and staged files:

git status        

To view the differences between the working directory and the staging area:

git diff