Ultimate Bitbucket for Automating Workflows

CHAPTER 1

Getting Started with Git

Introduction

In this chapter, we will introduce Git, focusing on its core features, the process of installing and configuring Git, and key commands used for various operations.

By the end of this chapter, you will have a comprehensive understanding of Git. You will learn how to use Git to track changes, maintain a detailed history of your code, and collaborate effectively with your team in a structured and organized way.

Structure

In this chapter, we will cover the following topics:

Git: A Definition

A Brief History of Git

Fundamental Git Concepts

Installing Git

Set Up a Local Git Repository

Git Configuration (Config)

.git folder

Git Commit

.git Folder Post-Commit

Git Branch

Merging in Git

Merging Changes

Understanding Merge Types

Git Merge Conflict

Resolve a Merge Conflict

Git Rebase

Git: A Definition

Git is an essential tool in modern software development, offering a robust system for version control and team collaboration. Imagine you are writing a document with a team and everyone is making edits. Git enables you to save various versions of the document, review the changes made, identify who made them, and seamlessly merge necessary updates. If needed, you can effortlessly revert to an earlier version. Think of it as a rewind button for your project, ensuring efficient and well-organized teamwork.

A Brief History of Git

Git was originally developed by Linus Torvalds, the creator of the Linux operating system kernel, in 2005. At the time, Torvalds and the Linux community were using a proprietary version control system. When this system’s licensing terms changed, the Linux community needed a new, free, and open-source version control system that could handle a large number of contributors with ease.

Let us Get Started!

Before delving into the specifics of Git, it is important to first understand Distributed Version Control Systems (DVCS). A DVCS is a type of version control system where each user maintains a complete copy of the entire repository, including all historical versions of the project. This approach is decentralized, meaning there is no single central server managing the repository. Instead, every participant has their own local copy.

Git is a prominent example of a DVCS. It is designed to handle projects of any size with efficiency and speed. Unlike traditional systems that rely on a central server, Git provides each user with a local copy of the repository. This decentralized setup offers several advantages:

Efficiency: Local operations are executed quickly because they do not depend on a central server.

Flexibility: Users can experiment with changes and create branches without impacting the main project until they are ready.

Robustness: The decentralized nature ensures that the project’s history is preserved across multiple locations.

To visualize how a DVCS such as Git works, consider the following simplified diagram:

Figure 1.1: Git DVCS

In this diagram:

Local Git Repository: Each user, represented by Workspace 1 and Workspace 2, has a complete repository containing the entire project history. This allows users to work independently on their local machines without needing constant access to a central server.

Remote Git Repository: Acts as a central repository where users share their changes. This central hub facilitates collaboration by integrating updates from various local repositories.

Bidirectional Arrows: These arrows demonstrate the flow of changes between the local and remote repositories. They indicate that changes can be fetched from the remote repository to the local repositories and, conversely, pushed from the local repositories to the remote repository.

This distributed approach makes Git a powerful tool for both individual developers and collaborative teams, ensuring robust performance and reliable data management.

Fundamental Git Concepts

Let us understand some fundamental Git concepts:

Repository (Repo)

A repository is a storage location for your project, containing all files and their revision history. Each time you edit a document or file, the existing version becomes part of the history, and the new edited version is recorded as the latest version. Repositories can be local (stored on your machine) or remote (hosted on a server).

Commit

A commit represents a snapshot or state of your project saved at a specific point in time. Each commit is identified by a unique code using a cryptographic hash function, specifically SHA-1 (Secure Hash Algorithm 1). When a version is saved (that is, committed), it generates a 40-character hexadecimal string derived from the content of the commit and its metadata.

Branch

A branch in Git functions as a parallel version of your repository, allowing you to work on different aspects of your project simultaneously. By default, Git creates a branch named "main or master," depending on the configuration. You can create additional branches to introduce new features, apply bug fixes, or run experiments without affecting the main project. This approach promotes clean, organized development, especially when working in teams.

Branches are often referred to as "refs" (references), which are pointers to specific commits in your repository. These terms, branch and ref, are used interchangeably and will frequently appear in various contexts throughout this book as we explore Git’s functionality further.

Branch names can include:

Letters: A-Z, a-z

Digits: 0-9

Special Characters: -, _, ., /

However, branch names cannot contain spaces or certain symbols, such as:

* (asterisk)

? (question mark)

Clone

Cloning creates a local copy of a remote repository, including all its history and branches. This allows you to work on the project locally while maintaining a complete record of changes.

Here is a diagram illustrating the Repository, Clone, Branch, and a Commit:

Figure 1.2: Remote and Local Repo

In this diagram:

Repository: The top-level container.

Branch A: A single branch starting from the repository.

Commit 1: The only commit on Branch A.

Installing Git

Now that we have explored the core concepts of Git, let us dive into setting up a local Git repository and applying those concepts in practice. Git is supported across various operating systems, and in this section, we will guide you through the steps to install Git on major platforms: Windows, macOS, and Linux.

Git on Windows

Download the Git Installer: Go to the official Git website, https://git-scm.com/ and download the Git installer for Windows.

Run the Installer: Launch the downloaded installer and follow the on-screen instructions. You can proceed with the default settings or customize the installation according to your preferences.

Verify the Installation: Open Command Prompt or PowerShell and type git --version to verify that Git has been installed correctly.

Figure 1.3: Git Bash on a Windows

Git on macOS

Install via Homebrew: If Homebrew is installed on your system, you can install Git by running the command brew install git in the Terminal.

Alternative Method: If you prefer, you can also download the Git installer directly from the official Git website, https://git-scm.com/ and follow the provided installation instructions.

Verify the Installation: Open Terminal and type git --version to confirm that Git is installed.

Figure 1.4: Git on a Mac Terminal

Git on Linux

Using Package Manager:

For Debian-based distributions (for example, Ubuntu), install git by running:

sudo apt-get install git

For Red Hat-based distributions (for example, Fedora), use:

sudo yum install git

Verify the Installation:

Open a terminal and type git --version to ensure that Git is installed properly.

Figure 1.5: Git on a Linux Terminal

Set Up a Local Git Repository

With Git now installed, let us begin by setting up a local Git repository. This will also give us the opportunity to explore fundamental Git concepts we already discussed, such as branch and commit.

Create a Local Git Repository

We will start by creating a directory for your project and initializing it as a Git repository. In this example, we will create a directory called bitbucket-book on a macOS terminal and initialize a new Git repository within it.

Create a new directory: In the Terminal, run the following commands:

mkdir bitbucket-book

cd bitbucket-book

git init

Initialize the repository: After running the git init command, you should see a message as follows:

Initialized empty Git repository in /Users/suhassundar/Desktop/bitbucket-book/.git/

This message confirms that an empty Git repository has been created in the specified directory.

Figure 1.6: Git Repo Init

Setting the Default Branch

Upon initializing the repository, you might notice a warning about the default branch name:

hint: Using 'master' as the name for the initial branch. This default branch name

hint: is subject to change. To configure the initial branch name to use in all

hint: of your new repositories, which will suppress this warning, call:

hint:

hint:  git config --global init.defaultBranch

hint:

hint: Names commonly chosen instead of 'master' are 'main', 'trunk', and 'development'.

Git is informing you that the default branch name is master, but this can be configured based on the naming convention your team follows. Common alternatives include main, trunk, or development. For this example, we will stick with the master branch as the default.

Git Configuration (Config)

The git config command allows you to configure Git settings and preferences on your system. These settings determine how Git behaves, as well as storing user information such as your name and email, which are used to tag commits.

Common Usage of git config

Set your name: The following command sets your name in Git:

git config --global user.name Your Name

Set your email address: This sets the email associated with your Git commits:

git config --global user.email [email protected]

These settings ensure that all your commits are tagged with your name and email.

Figure 1.7: Git Configuration

Types of Git Configuration

Git allows configuration at different levels, each affecting a different scope:

System-wide configuration (--system): Applies to all users on the system and every repository on the machine. These settings are typically stored in /etc/gitconfig.

git config --system

Global configuration (--global): Applies to all repositories for the current user. These settings are stored in ~/.gitconfig or ~/.config/git/config.

git config --global

Local configuration (default): Applies only to the specific repository where the command is run. These settings are stored in .git/config inside the repository folder.

git config

.git Folder

Now that we have successfully created a Git repository, let us explore the contents of this repository. Since we have not added any data yet, you might wonder what an empty repository contains. When you initialize a repository with git init, a .git directory is created, which is hidden by default. This folder contains all the essential files Git needs to manage the version history of your project.

Listing the Working Directory Contents

You can list the contents of the repository directory, including hidden files, by running the following commands: ls -la

ls -la .git

Figure 1.8: .git directory contents

You will notice that the .git folder is present, containing various files and subdirectories. These elements are crucial for managing the internal workings of Git. Let us break down the contents of the .git directory and understand the role each file or folder plays.

Understanding the Contents of the .git Directory

HEAD(File): This file points to the current branch or commit that you are referencing. It essentially tells Git which commit you are