GIT: A Comprehensive Guide for Absolute Beginners

Introduction

GIT is a tool that helps you manage your code changes. When multiple people are working on a project, it's essential to keep track of all the changes and make sure everyone's work is in sync. GIT helps you do this by keeping a record of all the changes made to the code, who made them, and when they were made.

Think of GIT as a big, organized library. Each time you make a change to your code, GIT saves a snapshot of that change. These snapshots are called "commits." You can think of them as pages in a book. Each page has its own story, but together they form a complete story.

Now, let's say you made a mistake and need to go back to an earlier version of your code. With GIT, you can easily do that. You can go back to any previous snapshot and see what your code looked like at that time. It's like going back in time to fix your mistakes!

GIT also lets you collaborate with others on a project. When multiple people are working on the same code, GIT helps keep track of all the changes and makes sure everyone is working on the latest version. It's like a team of superheroes working together to save the world!

In essence, GIT is like a time machine and a library combined. It helps you manage your code changes, go back in time to fix mistakes and collaborate with others on a project.

Setting Up GIT on GitHub

Here's a step-by-step guide on how to set up GIT on GitHub:

Create a GitHub account at https://github.com/signup.
Once you've created an account, log in to GitHub and click the "+" icon in the top-right corner of the page. Select "New repository" from the dropdown menu.
Give your repository a name and description, and choose whether you want it to be public or private. Click "Create repository" to create the repository.
Now it's time to connect your local repository to the remote repository on GitHub. In your terminal, navigate to your local project folder and type:
```
  git remote add origin https://github.com/your-username/your-repository.git
```
This tells GIT where your remote repository is located. Make sure to replace "your-username" and "your-repository" with your actual GitHub username and repository name.
Push your local repository to the remote repository by typing:
```
  git push -u origin master
```
This sends your code to GitHub and sets the upstream branch to "master". Make sure to replace "origin" and "master" with the name of your remote repository and the branch you want to push to.
Once your code is on GitHub, you can collaborate with others by adding them as collaborators to your repository. Go to the "Settings" tab of your repository, click "Manage access", and invite collaborators by entering their GitHub usernames or email addresses.

GIT Workflow and Collaboration

Installing GIT

To install GIT on your computer, you can visit https://git-scm.com/downloads and download the appropriate installer for your operating system. Once you've installed GIT, you can access it via your terminal or command prompt.

Initializing a GIT Repository

This tells GIT that you want to start tracking changes to your code in this folder.

To initialize a GIT repository in your project folder, navigate to your folder in your terminal and type:

git init

Cloning a Remote Repository

This downloads a copy of the remote repository onto your local machine.

To clone a remote repository from GitHub, you can use the following command in your terminal:

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

Make sure to replace "username" and "repository" with the actual GitHub username and repository name.

Fetching and Pulling Changes

To fetch changes from a remote repository and update your local repository, use the following command:

git fetch

This retrieves any changes that have been made in the remote repository but doesn't apply them to your local repository. To apply the changes, use the following command:

git pull

This merges the changes from the remote repository into your local repository.

Staging and Committing

When you make changes to a file in a GIT repository, the changes aren't automatically tracked by GIT. Instead, you need to stage the changes and then commit them to the repository. Staging changes means that you are preparing them to be committed while committing changes means that you are saving them to the repository with a commit message.

Here's an example of how to stage and commit changes using GIT:

Navigate to your local repository in your terminal or command prompt.
Use the following command to see which files have changed since the last commit:
```
  git status
```
This will display a list of files that have been modified, added or deleted since the last commit.
To stage changes for a specific file, use the following command:
```
  git add filename
```
Replace "filename" with the actual name of the file you want to stage changes for. You can also use the command git add . to stage all changes in the repository.
After you've staged your changes, use the following command to commit them:
```
  git commit -m "commit message"
```
Replace "commit message" with a brief description of the changes you've made. This commit message should be descriptive and help others understand what changes you've made.

Finally, you're ready to push your changes.

Pushing Changes to a Remote Repository

To push changes from your local repository to a remote repository on GitHub, use the following command:

 git push origin master

This sends your changes to the remote repository and updates the "master" branch. Make sure to replace "origin" and "master" with the name of your remote repository and the branch you want to push to.

Making Pull Requests

To collaborate with others on a remote repository, you can create a pull request on GitHub to propose changes to the code. Here's how:

Fork the repository by clicking the "Fork" button on the repository's GitHub page.
Clone the forked repository to your local machine using the "git clone" command.
Make changes to the code and commit them to your local repository using the "git add" and "git commit" commands.
Push your changes to your forked repository using the "git push" command.
On the original repository's GitHub page, click the "New pull request" button and select your forked repository as the "base" repository and the original repository as the "compare" repository.
Review the changes in the pull request and click "Create pull request" to submit it.

Git Branches and Merging

In Git, a branch is essentially a separate line of development. When you create a branch, you create a separate copy of your repository's codebase that you can modify and experiment with without affecting the main codebase. This can be useful for testing new features, working on bug fixes, or experimenting with different code approaches.

Here's an example of how to create and use Git branches:

To create a new branch, use the following command:
```
 git branch branch-name
```
Replace "branch-name" with the name of the branch you want to create. For example, if you want to create a new branch called "new-feature", you would run 'git branch new-feature'.
To switch to the new branch you just created, use the following command:
```
 git checkout branch-name
```
Replace "branch-name" with the name of the branch you want to switch to. For example, if you want to switch to the "new-feature" branch you just created, you would run 'git checkout new-feature'.
Once you're on your new branch, you can make changes to your code just like you normally would. When you're ready to commit your changes, you can use the same 'git add', 'git commit', and 'git push' commands as above.
To merge your changes from your branch back into the main codebase, you can use the following commands:
```
 git checkout main
 git merge branch-name
```
Replace "main" with the name of the branch you want to merge your changes into (usually the main branch), and "branchname" with the name of the branch you want to merge (in this case, the "new-feature" branch).

Git merge is when you're combining changes from different branches. Git takes the changes from one branch and applies them to another branch, merging the two branches together. This is useful for combining changes from multiple contributors, testing new features before merging them into the main codebase, and more.

Conclusion

In conclusion, Git is a powerful tool that allows developers to track changes to their code, collaborate with others, and experiment with new features without fear of breaking their codebase. With Git, developers can create branches to work on different features or bug fixes, merge those changes back into the main codebase, and roll back changes if necessary.

Git also provides a variety of other features such as remote repositories, pull requests, and code reviews that help make collaboration easier and more efficient. By using Git, developers can work together more effectively, share code more easily, and build better software faster.

While Git can take some time to learn and master, it's an essential tool for modern software development.