GIT_Overview.

Mithilesh Singh
GitHub
How to start
with git and create a
repository in Github??

GIT
• Git is a version control system. It has distributed architecture.
• It provides a flexible environment to work collaboratively and
securely.
• You can create and merge repositories using Git.
• Git facilitate the branching and merging of files within the main
repository.
• Git allows every user to have a copy of the project files locally,
thus making the files in the server secure.
• There are three level of Configuration in git, local, system and
global level.
• User settings in Git are mainly defined at global level,
because they correspond user level settings for all repositories.

Version Control
System
It is also known as "revision control",
"source control", or "source code
management".

Why VersionControl System(Git)?
• Have you ever made changes to a file or code
by mistake that you wanted to revert later?
• Ever lost a code or file?
• Do you have a backup of code which you write
or change every day.
• Do you ever have maintain multiple versions of
a code or file and analyze the differences.
• Do you ever have to share your code or let
other people work on it?
• Do you ever need to track the work
being done in details?
• Do you need to experiment with your
codes without messing up the
current work?

Benefits of
Version
Control
System
Reduce possibilities of errors and conflicts
meanwhile project development through
traceability to every small change.
Enhances the project development speed by
providing efficient collaboration.
For each different contributor of the project a
different working copy is maintained and not
merged to the main file unless the working copy is
validated. A most popular example is Git, Helix core,

Types of Version Control Systems
• There are two main types of version control
systems:
a. centralized and b. distributed version control
systems.
• a. Centralized version control systems(CVCS)
• b. Distributed version control systems(DVCS)

Centralized version control systems:
It is a type of version control system with a single server containingallversion of the code files.
This set up helpsevery contributor(Programmer) to know what the others are working on.
Programmer will "commit" their changes to thiscentral server.
Note:
Commiting a change simply means recording the changes in the central system. Other programmers can then
see this change.Theycan also pull down changes.

Centralized Version Control Workflow

Downside of CVCS
• It has some downsides as well which led to the
development of DVS. The most obvious is the
single point of failure that the centralized
repository represents if it goes down during that
period collaboration and saving versioned
changes is not possible. What if the hard disk of
the central database becomes corrupted, and
proper backups haven’t been kept? You lose
absolutely everything

Distributed Version Control System
• Distributed version control systems contain multiple repositories. Each user
has their own repository and working copy. Just committingyour changes
will not give others access to your changes. This is because commit will
reflect those changes in your local repository and you need to push them
in order to make them visible on the central repository. Similarly, When
you update, you do not get other’s changes unless you have first pulled
those changes into your repository.

KeyPoints
It is a type of version control
system, this system is not rely
on the central server to store
the project files version, instead
every developer clones a copy
of the repository and has the
full history of project.
This copy has all the metadata
of the original
Note: Metadata summarizes
basic information about data.
Or provide information about
other data.

Advantages of
DCVS:
• Performing actions other than pushing and
pulling changesets is extremely fast because
the tool only needs to access the hard drive,
not a remote server.
• Committing new changesets can be done
locally without anyone else seeing them.
Once you have a group of changesets ready,
you can push all of them at once.
• Since each programmer has a full copy of
the project repository, they can share
changes with one or two other people at a
time if they want to get some feedback
before showing the changes to everyone.

GITInstallationin the Window

• Access the URL:
https://git-scm.com/downloads

Openthe downloaded.exefile andclick next

Step : 11
Note: You should be able to see git installedversion in the console

•GIT Installation in the Mac

What is
minimum
Config to
Configure
Git?
To get the proper answer we can use below git command once.
git commit –m "<Commit message>"
If you are doing first time then git will indicatetwo missing
configuration,
1. user.name
2. user.email
That needs to be defined at a global level.
e.g.
git config –global user.email "<email.id>"
git config –global user.name "<user name>"
Note: to know about all configured list we can use command:
git config --list

Steps to create a Git Repository
• Create an empty directory: $ mkdir <directory-name>
• Convert the directory into repository: $ git init
• We can clubbed these two steps in a single step:
command: $ git init <directory_name>
Note:
git init command creates a hidden directory(.git) that stores all
the metadata required for it to function.(observe in next slide)

Checking hidden files
Main directory is empty
Default branch
How to check .git directory ??

Working Directory is nothing but the area
where we do code
manupulation(write/delete/update)etc.
Note: working directory containsuntracked
files, means git does not track it. So if
something goes wrong with your code, you will
not be able to recover it.
Staging Area is tracked zone for the git once the
changes have done by programmer in working
directory they can add those in staging area
using "git add" command.
$ git add <path of the file>.
Local Repository is the place where we can commit our all the changes with specific message, so that if anyonewant to
know about those changes they can easily get to know about changes.
$ git commit –m "<commit message>"

Note: please follow the last slide's flow
diagram to understandthe git
commands.
Step1: created one new file with the
help of touch command. Since this file is
created in working directory TestersZone
it is untracked file.
Note: to verify it we can use git status
command. It will be in red color
Step2: used git add command to convert
it into trackablefile(it is known as
staging area).
Note: file name will show in green color
after moving to stage area.
Step3: to move the changes into local
repository we can commit it with
commit message.
Note: to verify it we can use git status
command. We will get "nothing to
commit, working tree clean"

• Add and commit files we had
discussed in previous slide, so
once we will do successful
commit. Unique commit id will
be generating with author name
Date of commit and Commit
message(as mentioned in the
diagram) and that we can
observe on console using this
command
$ git log ---> see next slide for
more clarity.
What Information we get from
git log?

In one liner log
message you will be
getting only commit
message.
git log vs git log --oneline

Viewing and modifying the
files(class) inside framework:
1. If we are modifying something inside the files which is
already added intogit repo that will come under git
tracked file only.
Q?: How will I come to know where I have added new
file or modified into existing file
Ans: Observe diag 1 and diag2 All New files, git
will show
in untracked file
and there will
not be modified
tag with file
name
Modifiedfiles

Canwe trackthe changes inside thefiles in git?
Note: in last slide wesaw we havedone some changes in the file
and now it is under modified state.
Itmeans wehave one copy of file in our working directory(itis
modified file) and one copy is in stagearea(which wehad added
earlier and that is older version of file. That file does not have
currentchanges. Changes will reflect when we will add changes.)
Conclusion: wehave two diferent version of samefile one is in
working directory and other is in staging area.
Ques: I want tocomapare changes betweenthose twofiles?
Ans: use git diff command.
What do you mean by
tracking?
+ sign indicates what actually
changes are added in modified code, if
something we are removing it will come
with – sign.
@@ -0, 0 +1 @@ -->left side of , tells about older file and right side
of , tells about new file.
-0, --> - sign means old file and 0 means line starts will zero and end
on same.
0 +1 -->it says line startwith 0 and having total no of added lines
count 1.
@@ is a part of format.

Key points:
1. If there is more than one files and we want to see the changes in
particular file instead of "git diff" we can use "git diff <file_name>"
2. if we have already added our updatedfiles to stagingarea then
changes will not be reflecting using commands mentioned in point 1.
in this case we say working directory is in synced with stagingarea.
3. local repository: once we commit the changes then only it will
reflect into local repository.
4. If older changes are committed and latest changes are only added
that means older changes are in local repo and latest changes are in
stagingarea so we can differentiate the file versions available in
stage and local repo using below command.
"git diff --staged".
5. If we have so many commits and want to differentiate the
changes of any particular commit with updatedfile in staging then,
we can use commit id like "git diff <commit_id>".We can get
commit id using "git log" command.(observe in next slide)

We can compare the code of staging area and local repo using these
commit id's as well like
Steps:
1. Add the modifiedfile tothe git,nowitisunderstagingarea.
2. Nowwe have modifiedfile instagingandoldercreatedfile inlocal reposo
if we want todiff betweenfile'sversionwe caneitheruse commitidorHEAD
withcommandgitdiff.
Note:
git diff vs git diff --staged

Commit id's is only we denote as HEAD as you can see in the above snaps
Please follow the previous slides. All slides areinterrelated.Direct jumping to any slide will not be giving any idea
Commit and HEAD both are same??

Steps:
1. cat <file_name>shows the contet of the file
2. It helps toverify the changes inthe file.
3. In screeshotyoucanobserve I have usedcat demo.html twice to
verify the content intwodifferent versions of same file.
4. We can use HEAD or commit id bothwill work same. [see previous
side for more clarity]
5. After checking out toany versionof file we can use git status toget
the command of unstaging the file. Or we can use git reset it will also
un stage the staggedfile.[observepink text onthe snap]
How can we revert the earlier commit?

Yes it is possible using below commands

If you guys following the steps from the beginning, you will be awaring
like we have demo.html file and now I am creating one more file
demo1.html
Note:
1. To check the all stagging files we can use "git ls-files --stage"
2. To check the working directory files use "ls -lrt"
Steps followed:
1. git ls-files --stage --> checked all the stagged files.
2. git rm <file_name> --> removed file from stage and working
directory both.
3. git ls-files --stage --> verified deleted file from stagging.
4. ls -lrt --> verify deleted file from working directory.
5. git rm --cached <file_name> --> removed file from stagging only.
6. git ls-files --stage --> verify deleted file in stagging.
7. ls -lrt --> verify file is deleted only from stage not from working
directory.
8. git status --> checked deleted files and untracked files.
You can restore the deleted files using version(commit id or file
name)[observe pink line in screen shot]
e.g. git checkout Head~1 <file_name>.
Removing and restoring files in git

How to rename files in Git?
Steps:

Introduction of Git Hub
• It provides the web based interface which helps to copy
the entire commit history from the local repository to
the remote repository.
• Local repository refers as master.
• Remote repository refers as origin.
• Git hub provides all the functionlaity of distribution
control version tool(git) with some additional
feature for publishing the project and collaboration.

How to create repository in Git hub?
Using https Using ssh

Using https
Steps:
1. Access the github.com
url and click on sign up
option.
2. Fill all the details shown
in the screenshotand
create an account.

Once you will logged in
you can see this window
and then you can click on
Create Repositoryto
create one new repository.

Soon you will click on
create repositoryyou will
get this page.
1. Provide repository
name.
2. Select type of repository
either public or private.
Public repo can be
accessed by any one, for
private repo you have to
give the access.
3. Click on Create
repository

We have created one new
repo.
Case 1:
Suppose we have some
code changes in local
repositoryand after
creating remote
repository(git hub repo
which we have created
now) we want to push our
changes in remote repo so
we have to followfew
lines of
command[mentioned
below]
Perform these two lines of command one by one in the terminal. You will be asked to enter your credential. [observe the steps in next slide]
Note: repo link we can get from remote repo, exactly from where? You can observe in the above screenshot

How to
generate
token
Token
Screen
will look
like this
Use generated token here
More detail:https://stackoverflow.com/questions/6877
5869/support-for-password-authentication-was-
removed-please-use-a-personal-access-to
If you use password here

PullingChanges fromthe originrepository?
• In real time scenario what happens like so many
members will be working in the project and
pushing their codes in the remote repository. So to
get those changes in your local repo or to sync the
local repository to the remote (origin) repository
we need to pull the latest changes from remote
repo always(look at diagram).
e.g.
suppose there is one file in the remote repository
named demo1.html. And this file had few content.
Someone made some changes in this file and push
the changes to the git remote repo. Now in this
case i will have older version of demo1.html file if I
need new version of the same file we need to pull
the changes from the remote repository
Observe same scenario in the next 2 slides.

Follow the command mentioned in the screenshotto get the updated code fromremote repo to local
repo.
Totalnew inserted lines of
code.

Using ssh
To login with ssh key we need to create public key and add it in the repository.Follow the below steps.
Public key location
It shows key has been generated
Ssh public key

If you have not added any ssh key in your remote repo it will be showing message"you
don't have any SSH keys". You can "add new public key".

Go to repository setting--> SSH and GPG key--> New SSH key

Copy your ssh key fromthe terminal and paste it under key section and click on add ssh key
Note: Other process of adding local changes to remote repo will be same which we discussed in https case.
One minor change is like instead of https repo link use ssh repo link(copy it from remote repo, next to https)

Collaboration between local and remote repository happens
with the help of git pull and git push commands.
git pull command helps to get all the changes from remote
repository to the local repository.
git push command needs to push all the local changes to the
remote repository.
In this way we can use these two commands to keep our local
and remote repositories in sync.
Key Points:

How to deal with
multiplecommits
in the git?
• Scenario:
sometimes it might be the case two people
are doing changes in the same file at their
working directory and one of them pushed
his/her changes to the repo. After that if you
are trying to push you changes of the same
file to the repo you will not be able to do
so.
To overcome this we have to take pull from
remote repo so all the changes will come to
the local repo now we have to do force
commit and then git push to push all your
changes. In this way you can get other's
update in our local repo also.

• What is Branch concept in git?

• What Is need of the branch?
Branchhelps to keep our changes
in our working directory till the
time it is tested by programmer
once they are done with the
changes and want to share with
the other members of the team
they can merge their branches
with the remote (origin) branch
When a new branch is created, the complete commit historyof
the masterbranch is replicated.

It will show Current branch name.
It will show all the branch name. * will represent current branch
It is representingall the commits performedin the master
branch
Create a new branch with this command
Verifying newly created branch
Move to specific branch using this command
Verify the landed branch
Verify all the master branch commits are there in local branch
also
This single command can create and checkout to the new
branch
Verifying above command

Note: Our local changes(commits)will not be impecting masterbranch until code is not merged.
I have added one extra line in the demo1.html file
and commit the changes. This changes will not be
impacting masterbranch. To verify it just use git log
–oneline commandin demo1Branch and master
branch.
In demo1Branch we can observe we have one extra
commit which is not there in masterbranch.
it indicates our changes will be in local repo until
we push it to the remote repositoryand merged.

Steps to
merge the
Branches
• Check the difference between two branches
using command
git diff
<first_branch_name>..<second_branch_name>
• It will show, if there is any content difference
between these two branches.
Note: if there are more changes in more than
one files then all will be reflecting on console
using above command.
• Other way to identify the changes are using git
log command, it will show the extra commits in
case of additional changes.
• Observe all these practically in next slide.

1. If you will observe here we are using git log --oneline
command for the masterbranch and demo1branch.
In demo1branch we have two more commit id's as compare to
master branch. It shows we havemore changes in local
branch(demo1branch)compare to master branch.
If we want to look at exact content changes rather than commit
message, we can use git diff branch1..branch2 command.
Note: since we have extra contentsin demo1branch we can
merge that with the master branch.
Extra changes should me added with master branch so we have
to checkout to the master branch first.
Then use git merge <branch_name> --> branch_name means
branch whose code we need to add with master branch.
Once we merge the master branch with the demo1branch there
will not be any difference between those two branches.[observe
next]
git merge command

In step 1 I merged master branch with demo1branch.
And now you can observe both the branches havingsame commit messages. Means all changes are availablein both the
branches so localbranch and master branch both are in sync.
Note: In Real time projects we need to create PR(pull request) or MR(Merge request) against our changes to get it
reviewed by lead or tech head before merging it with master. Once they approvedyou can pull all new changes from
master.
After Merge??

Fast forward merge can be performed when there is a direct linear path from the
source branch to the target branch. In fast-forward merge, git simply moves the
source branch pointer to the target branch pointer without creating an extra
merge commit. ... In git a branch is nothing but a pointer to a commit.
As you can observe in the
screenshot, B is the master
branch and we have two
new commits
(features/bug fixes) and
there is no any other
commits to the master
branch so we can easily
merge the latest commit
with master branch and
shift master tag to D as you
can observe in diag. So no
need to create extra
commit for that. Thisis fast
forward merge

Note: look at previousslide first to get
the understandingon Fast forward
merge first.
In this merge process as you can
observe in the diagram B is master
branch and we would have feature
changes or fixes at D but same time
there might be some other changes
which pushed to master B so in this
case we can't make D as master branch
or else other's changes will be lost
[pointed by E]. so to avoidthis we can
pull all the master branch changes to
our local and on top of that we can add
our changes and create one new
commit that is F in this case. This F now
can be marked as master branch
because it will have all the changes.

git stash command helps to checkout the other branches without commit the current changes.
Take the scenario like you are working in a local branch and having some updatesthere but you need to checkout master
branch for some reason so in this case you can stash your all changes using git stash command and then easily checkout.
We have to commit the changes or stash before checking out the branch. Git stash create a snapshot of your current changes
and move your branch to last commit so when ever we want we can get those changes usinggit stash apply command.
git stash save command helpsto stash current changes with user's message. User can paasany messgae to identify stashed
code easily.
Basic difference between git stash apply and git stash pop command is, pop will remove the current changes snapshot once it
is used so that you can not use againand again.
git stash list provides all the stashed list.
Git Stash??

What is git clone?
• Cloning is the process to create a copy of original git repository in our local and
link with the original git repository to work with collaboration.
• Let's understand the steps:
1. Create a new folder in your system.
2. Navigate to the folder and open command line inteface.
3. Copy the git repository url from the git repo and use git
clone <repo link> in CLI and enter.
4. You might have asked credential, so type your credential and enter
5. You will have copy of original git repository now you can create your own
branch and add your changes.
Note: how to create branch and add changes and merge it with original
repository all have covered in previous slides.

We have completed most of the part of Git and Git repository but one question where most of the
people feel trouble I.e.
What is difference between git, gitlab, git hub and bitbucket?
The main difference between Git and Bitbucket, gitlasb, github is that Git is a distributed version control
system while Bitbucket, gitlasb, github is a web-based version control repository hosting service for
development projects that use Git.
The version control system allows the software developer to share code and to maintain the history of their work. It
can store the modification on files and source code. Version control system saves the state of the project and saves
them each time the user does a modification on the project. Each saved state of the project is called a version. Overall,
Git is a version controlsystem, whereas Bitbucket, gitlasb, github is a version control hosting service.
For deeper insights you can visit below links:
https://www.geeksforgeeks.org/bitbucket-vs-github-vs-gitlab/
https://stackshare.io/stackups/bitbucket-vs-github-vs-gitlab

GIT_Overview.

Recommended

More Related Content

Similar to GIT_Overview. (20)

More from Mithilesh Singh (20)

Recently uploaded (20)

GIT_Overview.