Git and GitHub - A Brief Overview • Neural Nets

What is Git?

Git is a distributed version control system (DVCS) that helps developers track changes in their codebase over time. Created by Linus Torvalds in 2005, Git enables collaboration on software projects by allowing multiple contributors to work on the same code, track revisions, and merge changes efficiently. Git’s key strength lies in its ability to manage large, branching code repositories while preserving the integrity and history of the code.

What is GitHub?

GitHub is a cloud-based platform that hosts Git repositories. While Git is the version control tool, GitHub adds a social, collaborative layer by providing a web-based interface for storing and managing Git repositories. GitHub offers features like pull requests, issue tracking, project management, and code reviews, making it a go-to tool for open-source projects and professional development teams.

Key Differences Between Git and GitHub:

Tool vs. Platform: Git is the actual version control tool, while GitHub is a web-based platform that leverages Git.
Local vs. Cloud: Git operates locally on your machine, enabling version control and branching, whereas GitHub allows for hosting repositories remotely and facilitates team collaboration.
Functionality: GitHub extends Git’s functionality with additional features like a visual interface, project management tools, and cloud-based collaboration.
Hosting: GitHub stores code remotely, allowing contributors to work from different locations, whereas Git manages code repositories locally unless configured to push to a remote server.

Now, let’s explore how to use Git with a focus on both basic and advanced commands.

Basic Git Commands

Below are essential Git commands that every developer should know. These commands help in managing repositories, committing changes, and collaborating with teams.

git init
Initializes a new Git repository in your project directory.
Terminal window
```
git init
```
This command creates a .git directory to start version control.
git clone
Clones a repository from a remote location (e.g., GitHub) to your local machine.
Terminal window
```
git clone <repository_url>
```
git add
Stages files to be committed in the next commit.
Terminal window
```
git add <filename>
```
To add all files in the directory:
Terminal window
```
git add .
```
git commit
Commits staged changes to the local repository with a descriptive message.
Terminal window
```
git commit -m "your commit message"
```
git status
Displays the status of the working directory and staging area (tracked, untracked, modified files).
Terminal window
```
git status
```
git push
Pushes committed changes from the local repository to the remote repository.
Terminal window
```
git push origin <branch>
```
git pull
Fetches and merges changes from the remote repository to your local branch.
Terminal window
```
git pull
```
git branch
Lists, creates, or deletes branches.
Terminal window
```
git branch
```
To create a new branch:
Terminal window
```
git branch <branch_name>
```
git checkout
Switches to a different branch.
Terminal window
```
git checkout <branch_name>
```
git merge
Merges the specified branch into the current branch.
Terminal window
```
git merge <branch_name>
```
git log
Displays the commit history.
Terminal window
```
git log
```
git remote
Manages connections to remote repositories.
Terminal window
```
git remote -v
```
git diff
Shows the changes between commits, branches, or the working directory.
Terminal window
```
git diff
```
git reset
Unstages files from the index (staging area).
Terminal window
```
git reset <filename>
```
git rm
Removes files from the working directory and the index.
Terminal window
```
git rm <filename>
```
git mv
Renames or moves files.
Terminal window
```
git mv <old_filename> <new_filename>
```
git stash
Temporarily saves changes that are not ready to commit.
Terminal window
```
git stash
```
git tag
Creates a tag for marking specific points in the repository’s history (e.g., version releases).
Terminal window
```
git tag <tag_name>
```

git config
Configures Git settings, such as the user name and email.

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

git show
Displays information about a specific commit.
Terminal window
```
git show <commit_id>
```

Advanced Git Commands

These commands help you dive deeper into more complex scenarios like rebasing, patching, and working with specific histories or submodules.

git rebase
Reapplies commits on top of another base tip to maintain a cleaner commit history.
Terminal window
```
git rebase <branch_name>
```
git cherry-pick
Applies a specific commit from one branch to another.
Terminal window
```
git cherry-pick <commit_hash>
```
git bisect
Finds the commit that introduced a bug by performing a binary search between commits.
Terminal window
```
git bisect start
git bisect bad
git bisect good <commit_hash>
```
git submodule
Manages repositories inside other repositories as submodules.
Terminal window
```
git submodule add <repository_url>
```
git reflog
Shows a log of changes to the local repository, including commits that are no longer visible in the commit history.
Terminal window
```
git reflog
```
git filter-branch
Rewrites branches by applying filters on the commit history (e.g., removing sensitive data).
Terminal window
```
git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch <filename>'
```
git blame
Shows who made the last modification to each line in a file.
Terminal window
```
git blame <filename>
```
git archive
Creates an archive of the files in a particular commit or branch.
Terminal window
```
git archive --format=zip HEAD > latest.zip
```
git gc
Cleans up unnecessary files and optimizes the local repository.
Terminal window
```
git gc
```
git clean
Removes untracked files from the working directory.
Terminal window
```
git clean -f
```
git revert
Reverses the effects of a previous commit without modifying the history.
Terminal window
```
git revert <commit_hash>
```
git reset --hard
Resets the index and working directory to match a specific commit, discarding all changes.
Terminal window
```
git reset --hard <commit_hash>
```
git ls-tree
Lists the contents of a tree object, including file names, paths, and modes.
Terminal window
```
git ls-tree <branch_name>
```
git fsck
Verifies the integrity of the repository.
Terminal window
```
git fsck
```
git describe
Provides a human-readable name for a commit based on tags and the number of commits since the last tag.
Terminal window
```
git describe
```
git pull --rebase
Rebase instead of merging changes from the remote repository when pulling updates.
Terminal window
```
git pull --rebase origin <branch>
```
git diff --cached
Shows differences between the staging area and the last commit.
Terminal window
```
git diff --cached
```
git remote prune
Removes references to branches that no longer exist on the remote.
Terminal window
```
git remote prune origin
```
git fetch --all
Fetches updates from all remotes.
Terminal window
```
git fetch --all
```
git cherry
Shows which commits have not yet been applied to a branch.
Terminal window
```
git cherry -v
```

Conclusion

Git is a powerful version control system that, when combined with GitHub, makes collaborative development smoother. Understanding the fundamental and advanced commands will help you manage codebases effectively, allowing for seamless collaboration and code integrity. Whether you’re working on a solo project or part of a larger team, mastering Git commands is essential to becoming a proficient developer.