Introduction to Git

What is Git?

Overview of Version Control Systems (VCS)

Version Control Systems (VCS) are tools that help developers manage changes to source code over time. They track modifications, allow collaboration, and enable reverting to previous versions of code. VCS can be categorized into two main types:

• Centralized Version Control Systems (CVCS): Have a single central repository where all versioned files are stored. Changes are committed to this central repository, and developers check out files from it. Examples include CVS and Subversion (SVN).

• Distributed Version Control Systems (DVCS): Every developer has a complete copy of the entire repository history on their local machine. Changes are committed locally and pushed to or pulled from remote repositories. Examples include Git and Mercurial.

Differences Between Centralized and Distributed VCS

1. Repository Structure:

   • Centralized VCS: There is one central repository. Developers check out and commit changes to this central location. If the central server goes down, developers can’t commit changes until it’s back up.
   • Distributed VCS: Each developer has a local repository that includes the full history of the project. This allows working offline and enables greater flexibility in how and when changes are shared.

2. Collaboration:

   • Centralized VCS: Developers need to be connected to the central server to commit changes. Collaboration requires coordination with the central server.
   • Distributed VCS: Developers can work offline and only need to synchronize with others occasionally. This allows for more decentralized workflows.

3. Branching and Merging:

   • Centralized VCS: Branching and merging can be more complex and less efficient, often requiring more manual intervention.
   • Distributed VCS: Branching and merging are often more efficient and streamlined. Git, for example, has powerful branching and merging capabilities that are integral to its design.

4. History and Backup:

   • Centralized VCS: The history is stored in the central repository, so if it’s lost or corrupted, the entire history can be lost.
   • Distributed VCS: Each clone contains the full history of the project, providing better redundancy and backup options.

Key Features and Benefits of Git

Git is a popular distributed version control system with several key features:

1. Branching and Merging:

   • Git makes it easy to create and manage branches. This allows for experimenting and working on features without affecting the main codebase. Merging branches is efficient and can be handled automatically or manually.

2. Distributed Architecture:

   • Every developer has a complete local copy of the repository. This allows for offline work and provides robust backup and redundancy.

3. Commit History:

   • Git tracks changes with commit history, allowing you to view, revert, or roll back to previous versions of the code. Each commit is uniquely identified by a hash.

4. Staging Area:

   • Git uses a staging area (index) where changes can be prepared before committing. This allows for more control over what changes are included in each commit.

5. Efficient Storage:

   • Git uses a combination of compression and data deduplication to store repository data efficiently.

6. Collaboration and Integration:

   • Git supports various workflows for collaboration, such as pull requests and code reviews. It integrates well with platforms like GitHub, GitLab, and Bitbucket.

7. Speed:

   • Operations like commit, branch, and merge are optimized for performance, making Git fast even with large repositories.

8. Open Source:

   • Git is open-source software, which means it is freely available and has a large community of contributors and users.

Setting Up Git

Installing Git on Different Operating Systems

1. Windows:

• Download: Visit the Git for Windows website and download the installer.
• Run the Installer: Follow the prompts in the setup wizard. You can choose to use Git from the command line and also from 3rd-party software.
• Verify Installation: Open Command Prompt or Git Bash and type git --version to ensure Git is installed.

2. macOS:

• Using Homebrew (recommended): If you have Homebrew installed, you can install Git by running:

  brew install git

• Using Installer: Alternatively, you can download the Git installer from the Git website and follow the installation instructions.
• Verify Installation: Open Terminal and type git --version.

3. Linux:

• Debian-based Systems (e.g., Ubuntu):

  sudo apt update
  sudo apt install git

• Red Hat-based Systems (e.g., Fedora):

  sudo dnf install git

• Verify Installation: Open Terminal and type git --version.

Configuring Git

After installing Git, you need to configure some settings to personalize your Git environment:

1. Set Username and Email: These settings are used to identify the author of commits.

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

2. Set Default Text Editor: You can choose your preferred text editor for Git commands that require a text editor (e.g., commit messages).

Example for setting VS Code:

git config --global core.editor "code --wait"

Example for setting Vim:

git config --global core.editor "vim"

Basic Git Commands

1. Check Git Version: To verify your Git installation and view the version:

git --version

2. Configure Git Settings: To configure your Git environment, use the git config command:

• View Global Configuration:

  git config --global --list

• Edit Configuration: You can also manually edit the .gitconfig file in your home directory.

By understanding these concepts and commands, you’ll be equipped to effectively use Git for version control in your development projects.