Git

GIT: A BRIEF INTRODUCTION
Eng. Amjad Mahfoud
amjadoof@gmail.com
8 - Nov - 2018
1

Slides Structure
Introduction
What is GIT
Using Git
Basic Git commands
Further Reading
2

Introduction
General Prenciples
3

What is Git?
• Git is a distributed version control system for managing source code.
• Ok, so what is version control?
• Simply put, version control is a system for tracking changes to files.
• As you modify files, the version control system records and saves each
change.
• This allows you to restore a previous version of your code at any time.
Eng. Amjad Mahfoud 4amjadoof@gmail.com

What is Git?
• Without a version control system, you are stuck manually saving
multiple versions of your file using different dates and/or names (e.g.
12-02-2016-monkey_code.php; 12-03-2016-monkey_code.php).
• This method is time-consuming and impractical when you are dealing
with hundreds of files.

What is Git?
• Renaming a file also doesn't give you any context as to what changes
were made or who they were made by.
• When multiple team members edit the same file, overwriting may
occur and it becomes difficult to keep up with the latest file version.
• With Git, you can easily follow your source code's revision history and
track changes.
• You can also go back in time to learn about how the version has
changed and who has made the changes.
• When the latest version of a file is on a shared repository, Git will
prevent unintentional overwrites by anyone on your team who has an
older version of the file.

Git makes it easy to:
• Keep track of code history
• Collaborate on code as a team
• See who made which changes
• Deploy to staging or production

Git workflow
• There are three main components of a Git project:
• Repository
• Working tree
• Index
Eng. Amjad Mahfoud amjadoof@gmail.com 8

The repository:
or repo, is the “container” that tracks the changes to your project files.
It holds all the commits—a snapshot of all your files at a point in time—
that have been made. You can access the commit history with the Git
log.

The working tree
or working directory, consists of files that you are currently working on.
You can think of a working tree as a file system where you can view and
modify files.

The index
or staging area, is where commits are prepared. The index compares the
files in the working tree to the files in the repo. When you make a
change in the working tree, the index marks the file as modified before
it is committed.

The three main components of a Git project:
the repository, index, and working tree.

The basic Git workflow:
• Modify files in the working tree.
• Stage the changes you want to be included in the next commit.
• Commit changes. Committing will take the files from the index and
store them as a snapshot in the repository.

Three states of Git files
• Modified
• Staged
• Committed
When a file is first modified, the change can only be found in the working
tree.
You must stage the changes you want to be included in your next commit.
The index contains all file changes that will be committed.
Once you have finished staging files, commit them with a message describing
what you changed.
The modified files are now safely stored in the repo.

Getting Git
• Get the latest: http://git-scm.com

Creating a repository
After installing Git on your machine, the first thing you'll need to do is
set up a repository.
A repository (repo) is a centrally located folder for storing all your code.
Once you create a Git repository with your files and directories, you can
start tracking changes and versions.
In this section, you'll learn how to get a repository up and running.

Remote repositories and local repositories
• There are two types of Git repositories: remote and local.
• A remote repository is hosted on a remote, or off-site, server that is
shared among multiple team members.
• A local repository is hosted on a local machine for an individual user.
• While you can take advantage of Git version control features with a
local repository, collaboration features—like pulling and pushing code
changes with teammates—will be better suited on a remote
repository.

How to create a repository
• There are two ways to create a local repository on your machine. You
can create a new repository from scratch using a file folder on your
computer or clone an existing repository.

Git init
• You can create a new repo from scratch using the git init command. It
can be used to introduce Git into an existing, unversioned project in
order to start tracking changes.

Git clone
• Use the git clone command to copy a remote repository onto your
local machine.
• By default, git clone automatically sets up a local master branch that
tracks the remote master branch it was cloned from.

Recording changes
• Now that you understand how to create a git repository, you'll need to
know how to save file changes.
• It is important to note that Git does not automatically save every
change you make. You must tell Git which changes you want to be
recorded by staging those changes. After staging, you can commit the
changes so that they are recorded in the repo.

Making changes
• As we mentioned in the Git workflow section, changes are made in the
working tree—a directory consisting of the files you are currently
working on. The working tree is where you edit files, add new files,
and remove files that are no longer needed.
• All files that are changed in the working tree are noted as modified in
the index. An index is a staging area where new commits are prepared.
It sits between the repository and working tree.
• Changes made in the working tree will not be saved directly to the
repository. All changes must first be staged in the index in order to be
saved in the repo. Only the files in the index are committed to the
repo.

Git commit
• The git commit command enables you to record file changes in the
repository's Git history.
• By committing, you will be able to view all changes chronologically in
the respective file or directory.

Commands
Basic Git commands
24

Configure tooling
Configure user information for all local repositories
$ git config --global user.name "[name]"
Sets the name you want attached to your commit transactions
$ git config --global user.email "[email address]"
Sets the email you want attached to your commit transactions

Create repositories
Start a new repository or obtain one from an existing URL
$ git init [project-name]
Creates a new local repository with the specified name
$ git clone [url]
Downloads a project and its entire version history

Make changes
Review edits and craft a commit transaction
$ git status
Lists all new or modified files to be committed
$ git diff
Shows file differences not yet staged
$ git add [file]
Snapshots the file in preparation for versioning

Make changes
$ git diff --staged
Shows file differences between staging and the last file version
$ git reset [file]
Unstages the file, but preserves its contents
$ git commit -m"[descriptive message]"
Records file snapshots permanently in version history

Synchronize changes
Register a remote (URL) and exchange repository history
$ git fetch [remote]
Downloads all history from the remote repository
$ git merge [remote]/[branch]
Combines the remote branch into the current local branch
$ git push [remote] [branch]
Uploads all local branch commits to GitHub
$ git pull
Downloads bookmark history and incorporates changes

To use Git, developers use specific commands to copy, create, change,
and combine code. These commands can be executed directly from the
command line or by using an application like Git.
Here are some common commands for using Git:

• git init initializes a brand new Git repository and begins tracking an
existing directory. It adds a hidden subfolder within the existing
directory that houses the internal data structure required for version
control.
• git clone creates a local copy of a project that already exists remotely.
The clone includes all the project’s files, history, and branches.

• git add stages a change. Git tracks changes to a developer’s codebase,
but it’s necessary to stage and take a snapshot of the changes to
include them in the project’s history. This command performs staging,
the first part of that two-step process. Any changes that are staged will
become a part of the next snapshot and a part of the project’s history.
Staging and committing separately gives developers complete control
over the history of their project without changing how they code and
work.

• git commit saves the snapshot to the project history and completes
the change-tracking process. In short, a commit functions like taking a
photo. Anything that’s been staged with git add will become a part of
the snapshot with git commit.
• git status shows the status of changes as untracked, modified, or
staged.
• git branch shows the branches being worked on locally.

• git merge merges lines of development together. This command is typically
used to combine changes made on two distinct branches. For example, a
developer would merge when they want to combine changes from a feature
branch into the master branch for deployment.
• git pull updates the local line of development with updates from its remote
counterpart. Developers use this command if a teammate has made
commits to a branch on a remote, and they would like to reflect those
changes in their local environment.
• git push updates the remote repository with any commits made locally to a
branch.

For more information
• https://git-scm.com/docs

37
Thanks for listening
Eng. Amjad Mahfoud amjadoof@gmail.com

Git

More Related Content

What's hot

Similar to Git

Recently uploaded

Git