How to use github

Git is famous due to its unique features and widespread adoption across industries and development environments. Here are some key reasons for its popularity:

1. Distributed Version Control System (DVCS)

Ø Unlike centralized systems, Git allows every user to have a complete copy of the repository, including its full history. This ensures developers can work offline and sync changes later without losing progress.

2. Speed and Performance

Ø Git is optimized for speed, especially for operations like branching, merging, and committing. It handles large projects efficiently, making it suitable for software giants like Google, Microsoft, and Facebook.

3. Branching and Merging

Ø Git’s lightweight and flexible branching model makes it easy to create, switch, and merge branches. This supports collaborative workflows like Git Flow and trunk-based development, critical for modern software engineering.

4. Robust and Secure

Ø Git uses SHA-1 hashing for commits, ensuring data integrity. Its design prevents tampering with commit history, making it a reliable tool for tracking code changes.

5. Community and Ecosystem

Ø Git is supported by a vast developer community and integrates seamlessly with platforms like GitHub, GitLab, and Bitbucket. These platforms provide additional features like pull requests, issue tracking, and CI/CD pipelines.

6. Cross-Platform Support

Ø Git works on Linux, Windows, macOS, and more. This versatility allows teams with diverse setups to collaborate effortlessly.

7. Open Source and Free

Ø As an open-source tool under the GPL license, Git is free to use and modify. Its cost-effectiveness contributes to its dominance in commercial and open-source projects.

8. Widely Adopted Workflows

Ø Git enables efficient team collaboration with workflows like:

ü Feature branching

ü Code reviews via pull/merge requests

ü CI/CD integration

Ø These workflows promote productivity and code quality in software development.

9. Integration with DevOps and CI/CD Tools

Ø Git integrates well with popular DevOps tools (e.g., Jenkins, Travis CI, CircleCI). This makes it a cornerstone for modern software delivery pipelines.

10. Learning Resources

Ø There is a wealth of documentation, tutorials, and community support for learning Git, which lowers the barrier to entry for beginners.

Real-World Impact

Git’s features make it indispensable for software development, from small personal projects to enterprise-grade systems. Its widespread adoption across industries has made it the de facto standard for version control.

Step-by-Step Guide:

Here’s a step-by-step explanation of the Git commands you've provided, including how to use SSH for authentication and Git branching operations.

Git Commands Overview

Initialize a local Git repository:

bash

git init

This command initializes an empty Git repository in your current directory.

Configure Git with your username and email:

bash

git config --global user.name "kartik.cse43@gmail.com"

git config --global user.email "kartik.cse43@gmail.com"

This sets up your global Git configuration, ensuring that your commits have your user information.

Link the local repository to the remote repository (on GitHub):

bash

git remote add origin "https://github.com/KartikMandal/BChainInsurance.git"

This command sets the remote repository URL. origin is the default name for the remote, and this URL is where your code will be pushed.

Fetching Data from a Remote Repository

Get data from the remote repository (GitHub) to your local repository:

bash

git pull origin master

This fetches and merges the latest changes from the remote master branch into your local repository.

Branching Operations

Create a new branch from the master branch:

bash

git branch branchname

Example:

bash

git branch blockchain

This creates a new branch called blockchain from master.

Switch to the new branch:

bash

git checkout branchname

Example:

bash

git checkout blockchain

or, to create and switch to the branch at the same time:

bash

git checkout -b blockchain

Checking Status and Adding Files

Check the status of your working directory:

bash

git status

This command shows any changes made to the files and the current branch.

Add a single file to the staging area:

bash

git add filename

Example:

bash

git add kartik.txt

Committing Changes

Commit a single file with a message:

Bash

git commit -m "checkin for required"

Add all modified files to the staging area:

Bash

git add -A

Commit all files:

bash

git commit -a -m "checkin for required any message"

Viewing the Commit History

View the commit history:

bash

git log

Generating SSH Key for GitHub Authentication

Generate an SSH key for secure authentication:

bash

ssh-keygen

After generating the SSH key, it will prompt:

"Enter file in which to save the key," press Enter to save it in the default location.
"(y/n)?" Select y if you want to overwrite the existing key (if any).

View the public SSH key:

bash

cat /c/Users/kmandal/.ssh/kartik.pub

Copy the output and add the public key to your GitHub account under "SSH and GPG keys."

Test the SSH connection to GitHub:

bash

ssh -T git@github.com

After successful authentication, you can use SSH instead of HTTPS to interact with GitHub.

Pushing Code to GitHub

Switch to a specific branch:

bash

git checkout branchname

Example:

Bash

git checkout blockchain

Push the local branch to the remote repository:

bash

git push origin branchname

Example:

bash

git push origin blockchain

or, if it's the first push to the remote branch:

bash

git push -u origin blockchain

This workflow ensures that you can manage branches, commits, and use SSH for secure GitHub interactions. You can switch between branches, stage changes, commit your work, and push it to GitHub.

Installing

To begin with, it is essential to install Git in order to utilize its features. This can be accomplished quickly and easily using the apt package manager.

sudo apt install git-all

Basic setup

If you prefer, you can save your Git username and email address to avoid entering them repeatedly for future Git commands.

git config --global user.name "User Name"

git config --global user.email "email"

Colours

An often-overlooked feature is the ability to enable additional color coding in Git, which enhances the readability of command outputs.

git config --global color.ui true

Basic version control

Initialising git

We can now initiate version control for our project. Navigate to the desired directory in the terminal using the "cd" command, and then initialize a Git repository with the following command:

git init

This action will create a new subdirectory called .git, which contains all the essential files for your repository—a foundational structure for Git. At this stage, no files in your project are being tracked.

Adding and committing

To begin version-controlling existing files, you should first track those files and perform an initial commit. Start by adding the files you wish to include in your Git project.

git add <file>

git commit -m 'first commit'

Remote backup

Excellent! You have now initiated local versioning for your GitHub project. To save and back up your project remotely, you will need to create a remote repository on GitHub (which is free). Visit github.com to create a repository, and then use the repository link to set it as the origin for your local Git project, indicating where your code will be stored.

### General example

git remote add origin

https://github.com/user/repo.git

### Here is an illustration using one of my git repositories.

git remote add origin

https://github.com/KartikMandal/BChainInsurance.git

After that, you can proceed to push your code to GitHub, and just like that, your code is backed up!

git push origin master

Working with your files

Status checking

The primary command for checking the status of your files is git status. This command allows you to see which files have been committed and which remain uncommitted. If you execute this command after all files have been committed and pushed, you should see a message indicating that there are no changes.

$ git status

# On branch master

nothing to commit (working directory clean)

If you add a new file to your project that did not previously exist, running the git status command will display your untracked file as follows:

$ git status

# On branch master

# Untracked files:

# (utilize "git add <file>..." to include files in the upcoming commit)

##README

No files were added to commit, but there are untracked files present (use "git add" to start tracking).

This makes

$ git status really useful for a quick check of

This shows what you have already backed up compared to what exists only on your local machine.

Advanced file adding

There are several advanced methods for adding files to Git that can enhance your workflow. Rather than searching for all modified files and adding them individually, consider the following approach:

### Adding files one by one

git add filename

### Adding all files in the current directory

git add -A

### Adding all files changes in the current directory

git add .

### Selecting which changes to include (this will review all changes).

### changes and you can 'Y' or 'N' the changes)

git add -p

Advanced commits

Previously, we saw that we could commit a file to Git using

$ git commit -m "commit message" .

While this method works well for brief commit messages, a more detailed approach is necessary for complex updates.

### Commit staged file(s)

### This is generally applied for concise commit messages.

git commit -m 'commit message'

### Add file and commit in one shot

git commit filename -m 'commit message'

### Add file and commit staged file

git commit -am 'insert commit message'

### Changing your most recent commit message

git commit --amend 'new commit message'

# Combine a sequence of commits together into a single one

### You might use this to organise a messy commit history

git rebase -i

### This will give you an interface on your core editor:

# Commands:

# p, pick = use

commit

# r, reword = use

commit, but edit the commit message

# e, edit = use

commit, but stop for amending

# s, squash = use

commit, but meld into previous commit

# f, fixup = like

"squash", but discard this commit's log message

# x, exec = run

command (the rest of the line) using shell

Branching and merging

The master branch of your GitHub repository should consistently hold functional and stable code. However, you might also want to back up code that is still in development and not fully stable. For instance, if you are adding a new feature or experimenting with the code, you may frequently encounter issues, but it’s important to maintain a backup to track your progress!

Branching enables you to work on a distinct version of your code without impacting the master branch. When you create a branch, a complete copy of your master branch is generated under a new name. You can then make changes in this new branch independently, including committing files. Once your new feature is fully developed and the code is stable, you can merge it back into the master branch!

Branching

Here’s all of the things you need to create and work on a

branch:

### Create a local branch to work on

git checkout -b branchname

### Switching between 2 branches

git checkout branch_1

git checkout branch_2

### Pushing your new local branch to remote as backup

git push -u origin branch_2

### Deleting a local branch - this won't let you delete a branch

### that hasn't been merged yet

git branch -d branch_2

### Deleting a local branch - this WILL delete a branch even

if it

### hasn't been merged yet!

git branch -D branch_2

### Viewing all current branches for the repository,

including both

### local and remote branches. Great to see if you already have a

### branch for a particular feature addition, especially on bigger

### projects

git branch -a

### Viewing all branches that have been merged into your current

### branch, including local and remote. Great for seeing where all

### your code has come from!

git branch -a --merged

### Viewing all branches that haven't been merged into your current

### branch, including local and remote

git branch -a --no-merged

### Viewing all local branches

git branch

### Viewing all remote branches

git branch -r

# Rebase master branch into local branch

$ git rebase origin/master

# Pushing local branch after rebasing master into local

branch

$ git push origin +branchname

Merging

Excellent! You have successfully learned how to create a branch and manage the associated code. Once you finish implementing the new feature in your branch, the next step is to merge it back into the master branch to ensure that it contains all the latest code enhancements.

Here’s how to do it:

### First, ensure that you are viewing the master branch.

git checkout master

### Now merge your branch to master

git merge branch_2

That’s all there is to it! You may need to resolve any code conflicts between your branch and the master, but Git will guide you through the process once you enter the merge command.

Fixing mistakes and backtracking

Errors are a common occurrence in coding! What matters is our ability to rectify them.

Have no fear here! Git provides all the tools you need if you encounter an issue with the code you’ve pushed, overwrite something, or simply wish to amend a previous submission.

### Revert to the version of the code prior to the latest commit.

git reset HEAD

git reset HEAD -- filename

# for a specific file

### Revert to the version of the code prior to the latest commit.

git reset HEAD^ -- filename

# for a specific file

### Switch back 3 or 5 commits

git reset HEAD~3 -- filename

# for a specific file

git reset HEAD~5 -- filename

# for a specific file

### Switch back to a specific commit

### Where the '0766c053' is the commit ID

git reset 0766c053 -- filename

git reset 0766c053 -- filename # for a specific file

### The previous commands were what's known as "soft" resets. Your

### code is reset, but git will still keep a copy of the other code

### handy in case you need it. On the other hand, the --hard flag

### tells Git to overwrite all changes in the working directory.

git reset --hard 0766c053

Useful tips and tricks for Git

We have covered the essential details! Here are a few additional Git tips and tricks that could enhance your workflow.

Searching

### Searches for parts of strings in a directory

git grep 'something'

### Searches for parts of strings in a directory and the -n prints

### out the line numbers where git has found matches

git grep -n 'something'

### Searches for parts of string with some context (some lines

### before and some after the 'something' we are looking for)

git grep -C<number of lines> 'something'

### Searches for segments of a string and also displays lines preceding it.

git grep -B<number of lines> 'something'

### Searches for segments of a string and also displays lines following it.

git grep -A<number of lines> 'something'

###Seeing who wrote what

### Show alteration history of a file with the name of the author

git blame 'filename'

### Show alteration history of a file with the name of the author

### and the git commit ID

git blame 'filename' -l

Logging

### Show a list of all commits in a repository. This command shows

### everything about a commit, such as commit ID, author, date and

### commit message.

git log

### List of commits showing only commit messages and changes

git log -p

### List of commits with the particular string you are looking for

git log -S 'something'

### List of commits by author

git log --author 'Author Name'

### Show a summary of the list of commits in a repository. This

### shows a shorter version of the commit ID and the commit message.

git log --oneline

### Show a list of commits in a repository since yesterday

git log --since=yesterday

### Shows log by author and searching for specific term inside the

### commit message

git log --grep "term" --author "name"

Git workflow explanation is comprehensive and covers all essential aspects of initializing a repository, configuring Git, branching, SSH authentication, and pushing code to GitHub. Here's a polished and structured summary of the workflow with enhanced clarity:

Git Workflow with SSH Authentication

Installing Git

To install Git, run:

bash

sudo apt install git-all

1. Initialize a Local Git Repository

bash

git init

Initializes an empty Git repository in your current directory.

2. Configure Git User Information

Set up your Git username and email:

bash

git config --global user.name "Your Good Name"

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

Enable colored output for better readability:

bash

git config --global color.ui true

Example:

bash

git config --global user.name "kartik.cse43@gmail.com"

git config --global user.email "kartik.cse43@gmail.com"

Ensures your commits are associated with your user identity.

Branching Operations

Create a New Branch:

bash

git branch branchname

Example:

bash

git branch blockchain

Switch to the New Branch:

bash

git checkout branchname

Example:

bash

git checkout blockchain

Create and Switch Simultaneously:

bash

git checkout -b branchname

Managing Changes

Check Status:

bash

git status

Shows changes and the current branch.

Stage Changes:

Single file:

bash

git add filename

Example:

bash

git add kartik.txt

All modified files:

bash

git add -A

Commit Changes:

Single commit message:

bash

git commit -m "Commit message"

All changes at once:

bash

git commit -a -m "Commit message"

Push Code to GitHub

Switch to a Branch:

bash

git checkout branchname

Example:

bash

git checkout blockchain

Push the Branch:

bash

git push origin branchname

Example:

bash

git push origin blockchain

Set the Upstream Branch:

bash

git push -u origin branchname

Sets the default remote for subsequent pushes.

Branching and Merging

Create a New Branch:

bash

git checkout -b new-branch

Switch Between Branches:

bash

git checkout branch-name

Push a New Branch to Remote:

bash

git push -u origin new-branch

Merge a Branch:

bash

git checkout master

git merge branch-name

Delete Branches:

bash

git branch -d branch-name # Delete a local branch (safe)

git branch -D branch-name # Force delete (unsafe)

Additional Notes

Using SSH Instead of HTTPS: Update your remote URL to SSH:

bash

git remote set-url origin git@github.com:KartikMandal/BChainInsurance.git

Check Branches:

View all branches:

bash

git branch

View remote branches:

bash

git branch -r

Working with Remote Repositories

Add Remote Repository:

bash

git remote add origin https://github.com/user/repo.git

Example

bash

git remote add origin "https://github.com/KartikMandal/BChainInsurance.git"

Links your local repository to a remote GitHub repository (replace the URL with your repository's URL).

Push to Remote:

bash

git push origin master

Pull Changes from Remote or Fetching Changes from the Remote Repository

bash

git pull origin master

Fetches and merges changes from the remote master branch into your local repository.

History and Logs

View Commit History:

bash

git log

git log --oneline # Compact view

Check File History:

bash

git blame filename

Reverting and Resetting

Undo Last Commit (Soft Reset):

bash

git reset HEAD

Hard Reset to a Specific Commit:

bash

git reset --hard <commit-id>

SSH Authentication

Generate an SSH Key:

bash

ssh-keygen

Copy Public Key:

bash

cat ~/.ssh/id_rsa.pub

Add this key to your GitHub account under Settings > SSH and GPG keys.

Test SSH Connection:

bash

ssh -T git@github.com

Switch to SSH for remote operations:

bash

git remote set-url origin git@github.com:user/repo.git

Advanced Tips

Interactive Staging:

bash

git add -p

Approve changes interactively.

Search Commit Logs:

bash

git log --grep "keyword"

git log --author="Author Name"

Rebase:

bash

git rebase origin/master

This guide covers essential operations, advanced features, and best practices, making it a versatile resource for Git users! Let me know if you need further details or specific examples.

Branching and Merging

Create a New Branch:

bash

git checkout -b new-branch

Switch Between Branches:

bash

git checkout branch-name

Push a New Branch to Remote:

bash

git push -u origin new-branch

Merge a Branch:

bash

git checkout master

git merge branch-name

Delete Branches:

bash

git branch -d branch-name # Delete a local branch (safe)

git branch -D branch-name # Force delete (unsafe)

History and Logs

View Commit History:

bash

git log

git log --oneline # Compact view

Check File History:

bash

git blame filename

Reverting and Resetting

Undo Last Commit (Soft Reset):

bash

git reset HEAD

Hard Reset to a Specific Commit:

bash

git reset --hard <commit-id>

SSH Authentication

Generate an SSH Key:

bash

ssh-keygen

Copy Public Key:

bash

cat ~/.ssh/id_rsa.pub

Add this key to your GitHub account under Settings > SSH and GPG keys.

Test SSH Connection:

bash

ssh -T git@github.com

Switch to SSH for remote operations:

bash

git remote set-url origin git@github.com:user/repo.git

Advanced Tips

Interactive Staging:

bash

git add -p

Approve changes interactively.

Search Commit Logs:

bash

git log --grep "keyword"

git log --author="Author Name"

Rebase:

bash

git rebase origin/master

This guide covers essential operations, advanced features, and best practices, making it a versatile resource for Git users! Let me know if you need further details or specific examples.

How to Tag a Code Commit in GitHub using Git

Tagging in GitHub helps in marking specific points in your project’s history, such as release versions (v1.0, v2.0, etc.) or important commits.

1. Creating a Tag in Git

Tagging a specific commit

Run the following command in your Git Bash or Terminal:

bash

git tag -a v1.0 -m "Version 1.0 - Initial Release"

🔹 -a v1.0 → Creates an annotated tag named v1.0
🔹 -m "Version 1.0 - Initial Release" → Adds a message for the tag

Tagging a past commit (with commit hash)

If you want to tag a specific commit, find its commit hash using:

bash

git log --oneline

Then, tag the commit using:

bash