Git Basics: A Guide for Software Engineers

Version control is a fundamental tool in software development. It helps teams manage changes, collaborate effectively, and maintain different project versions. Among the various version control systems available, Git stands out due to its distributed nature, flexibility, and widespread adoption. In this blog post, we'll explore the basics of Git and how you can use it to manage your code more efficiently.

What is Version Control?

Version control systems (VCS) are essential tools for software engineers. They allow you to:

Track Changes: Record modifications to your codebase over time.
Facilitate Collaboration: Work seamlessly with other developers on the same project.
Manage Versions: Maintain different versions of your project, making it easier to revert to previous states when necessary.

Introduction to Git

Git is a distributed version control system created by Linus Torvalds in 2005. Unlike centralised systems, Git allows every developer to have a full-fledged repository with complete history and full version-tracking capabilities on their local machine. This decentralised approach provides numerous benefits, including enhanced collaboration and offline work capabilities.

Setting Up Git

Before we dive into using Git, you'll need to install and configure it:

Install Git: Download and install Git from git-scm.com.

Configure Git:

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

These configuration settings ensure that your commits are associated with your name and email address.

Project Directory Setup

Let's start by creating a project directory and adding a Python file:

Create a directory:

 mkdir my_python_project
 cd my_python_project

Add a Python file:

 echo "print('Hello, World!')" > hello.py

Now we have a directory containing a Python file that we want to track with Git.

Initialising a Git Repository

To start tracking changes in your project, initialise a Git repository:

Navigate to your project directory:
```
 cd my_python_project
```
Initialise the repository:
```
 git init
```

This command sets up the necessary files and directories for version control within your project.

Checking Repository Status

To check the current state of your repository, use the git status command:

git status

This command shows which changes have been staged, which haven’t, and which files aren’t being tracked by Git yet.

Staging and Committing Changes

To save changes in your repository, follow these steps:

Stage changes:
```
 git add hello.py
```
Or stage all changes:
```
 git add .
```
Commit changes:
```
 git commit -m "Initial commit"
```

Staging lets Git know which changes you want to include in your next commit, and committing records these changes in the repository.

Viewing Commit History

To view the history of your commits, use the git log command:

git log

This command lists all the commits in your repository and details about each.

Connecting to a Remote Repository

To share your code with others or back it up, you can connect your local repository to a remote one, such as GitHub:

Create a repository on GitHub/GitLab/Bitbucket.

Connect your local repository to the remote repository:

 git remote add origin https://github.com/yourusername/your-repo.git

Pushing and Pulling Changes

To synchronise your local repository with the remote repository, use the following commands:

Push changes to the remote repository:
```
  git push -u origin master
```
Pull changes from the remote repository:
```
  git pull origin master
```

Branching and Merging

Branching allows you to work on features or fixes independently from the main codebase. Here’s how to manage branches:

Create a branch:
```
 git checkout -b feature-branch
```
Switch branches:
```
 git checkout master
```
Merge a branch:
```
 git merge feature-branch
```
Delete a branch:
```
 git branch -d feature-branch
```

Collaboration with Git

To collaborate with others, you may need to clone a repository and handle merge conflicts:

Clone a repository:

  git clone https://github.com/username/repo.git

Handling Merge Conflicts

Merge conflicts occur when changes from different branches conflict with each other. Here’s an example of what causes a merge conflict and how to resolve it:

Example of a Merge Conflict:

Two developers make changes to the same line in hello.py on different branches:
- Developer A's change on the master branch:
```
  print('Hello, World! - from master')
```
- Developer B's change on feature-branch:
```
  print('Hello, World! - from feature branch')
```
When merging feature-branch into master, a conflict occurs:
```
 git checkout master
 git merge feature-branch
```
Git will output a merge conflict message and mark the conflicting areas in the file.

Resolving the Merge Conflict:

Open the conflicted file (hello.py) and look for conflict markers:

 <<<<<<< HEAD
 print('Hello, World! - from master')
 =======
 print('Hello, World! - from feature branch')
 >>>>>>> feature-branch

Resolve the conflict by editing the file to combine or choose one of the changes:
```
 print('Hello, World! - resolved conflict')
```

Stage the resolved file and complete the merge:

 git add hello.py
 git commit -m "Resolved merge conflict in hello.py"

Conclusion

Git is a potent tool for managing your code and collaborating with others. By understanding the basics of Git commands and workflows, you can enhance your development process and work more efficiently.

For more advanced Git commands and in-depth learning, check out these resources:

Happy coding!

Getting Started with Git: A Practical Guide for Software Engineers