Collaborative development with Git | Workshop

Collaborative development with Git
Anuchit Chalothorn
anuchit@redlinesoft.net

Git Workshop
●
●
●
●
●
●
●

Overview
Git Basics
Undo Git Changes
Git Branches
Rewriting Git History
Git Remote Repository
Git Workflow

Overview
Version control is a system that records changes to a file or set of files
over time so that you can recall specific versions later. A VCS allows
you to:
●
●
●
●

revert files back to a previous state
revert the entire project back to a previous state
review changes made over time
see who last modified something

History of Git
Linux Kernel was use DVCS call BitKeeper, proprietary
software but in 2005 the company behind BitKeeper brokedown and tool’s free-of-charge was revoked. The Linux
development community develop their own tool.

Goal of Git
● Speed
● Simple design
● Strong support for non-linear development (1000+ for
parallel branches)
● Fully distributed
● Able handle a large project (data and size)

Git Basic
Git basic tutorial provide the important commands to work
with Git

Get Git
Download git at http://git-scm.com/downloads choose your
os version :)

Workshop 1
Download Git and install to your machine, after install try to
use git command.

Git config
The git config command lets you configure your Git
installation (or an individual repository) from the command
line.

Git config user.name
Define the author name to be used for all commits in the
current repository. Typically, you’ll want to use the -global flag to set configuration options for the current
user.
git config --global user.name <name>

Git config user.email
Define the author email to be used for all commits by the
current user.
git config --global user.email <email>

Git config core.editor
Define the text editor used by commands like git commit for
all users on the current machine. eg; vi
git config --system core.editor <editor>

Git config core.autocrlf
Config the line ending for your operating system
git config --global core.autocrlf true
git config --global core.autocrlf input

Git config color.ui
Config the line color for git message
git config --global color.ui auto

Workshop 2
Setup Git config to your profile; name, email, line break, ui
auto color and choose your favorite text editor.

Git init
The git init command creates a new Git repository.
git init
git init <directory>

Git init --bare
Shared repositories should always be created with the -bare flag

Bare

Non
Bare

Non
Bare

Non
Bare

Example
cd /repo
git init --bare my-project.git

my-project.git

Workshop 3
Create git repositories call myrepo as working repository
and master-proj as shared repository, see what is
difference of two repository.

Git clone
The git clone command copies an existing Git repository.
git clone <repo>
git clone <repo> <directory>

Origin

Working Copy

Collaboration
Central Repo to Working Copy
Collaboration

Repo to Repo Collaboration

SVN
Repo

Git
Repo

Git
Repo

Git
Repo

Example
git clone ssh://username@example.com/repo/my-project.git
cd my-project

example.com/repo/my-project.git

local repo

Workshop 4
create local git repo call master-proj and clone
master-proj to myproj and create a blank file called
README

Git add
The git add command adds a change in the working
directory to the staging area.
git add <file>
git add <directory>

Example
git add .
git commit

Add

Commit

git add hello.php
git commit
Working
Directory

Staged
Snapshot

Committed
History

Workshop 5
Add README to your repository

Git commit
The git commit command commits the staged snapshot to
the project history.
git commit -m "<message>"

Example
git add hello.php
git commit

hello.php

hello.php

hello.php

Workshop 6
Commit all change to your repository, create snapshot to
project history.

Git status
The git status command displays the state of the working
directory and the staging area.
git status

Workshop 7
Use git status after add, edit file or commit file.

Git log
The git log command displays committed snapshots. It lets
you list the project history, filter it, and search for specific
changes.

Example
Git Status

git log

Git Log

git log -n <limit>
git log --oneline
git log --stat
git log --author="<pattern>"
git log --grep="<pattern>"
git log <since>..<until>

Working
Directory

Staged
Snapshot

Committed
History

Workshop 8
Use git log to see the committed history of your repository.

Undo Git Changes
Working with previous revisions of your software project.

Git checkout
The git checkout command serves three distinct functions:
checking out files, checking out commits, and checking out
branches.
git checkout master
git checkout <commit> <file>
git checkout <commit>

Example
git log --oneline
git checkout a1e8fb5

a1e8fb5

Master

Example
git checkout master
git checkout a1e8fb5 hello.py

Add

Working
Directory

Commit

Staged
Snapshot

Committed
History

Workshop 9
Add 2 lines in in readme.txt and commit change to your
repository, check revision form git log and try to change to
the first state and try to change state back to the latest
revision (master)

Git revert
The git revert command undoes a committed snapshot. it
the ‘safe’ way to undo.
git revert <commit>

Example
git commit -am “update readme”
git revert 15df9b6

15df9b6

Workshop 10
repository, check revision form git log and try to revert to
previous version by using git revert

Git reset
The git reset command undo changes in dangerous
method — it is a permanent undo.
git reset <file>
git reset <commit>
git reset --hard
git reset --hard <commit>

Example
git reset --hard 15df9b6

Workshop 11
repository, check revision form git log and try to revert to
previous version by using git reset

Git clean
The git clean command removes untracked files from your
working directory.
git clean
git clean -f
git clean -df
git clean -xf

Example
touch somefile.txt
git reset --hard
git clean -df

Workshop 12
Create new file call index.php and try to use git clean
to delete untracked file.

Git Branches
First, we'll take a look at creating branches, which is like
requesting a new project history.

Git branch
The git branch command lets you create, list, rename, and
delete branches.
git branch
git branch <branch>

Example
git branch experiment
Master

Experiment

Workshop 12
Create new branch call issue123 for your current revision.
use git branch to show branches.

Git checkout
The git checkout command lets you navigate between the
branches created by git branch.
git checkout <existing-branch>
git checkout -b <new-branch>

Example
git branch experiment
git checkout experiment

Experiment

Master

Workshop 13
Change to branch issue123 add some file and commit to
this branch then change to master to compare.

Git merge
The git merge command lets you take the independent
lines of development created by git branch and
integrate them into a single branch.

Example
git merge experiment
git branch -d experiment
Experiment

Experiment

Master

Master

Workshop 14
Change to branch issue123 edit some file and commit
then change to master branch and merge issue123 to
master branch then delete issue123 branch.

Rewriting Git History
Git also designed to give you total control over your
development workflow, letting you define exactly what your
project history looks like; however, it also creates the
potential to lose commits.

Git rebase
Rebasing is the process of moving a branch to a new base
commit.
git rebase <base>

Example
feature
feature
feature

master
master

Example
# Start a new feature
git checkout -b feature master
# Edit files
git commit -a -m "Start developing a feature"
git checkout master
# Edit files
git commit -a -m "Fix security hole"

Example
# Merge back into master
git checkout feature
git rebase master
git checkout master
git merge feature

Git rebase -i
Running git rebase with the -i flag begins an interactive
rebasing session.
git rebase -i <base>

Example
git checkout feature
git rebase -i master
# Config merge method in change log
git checkout master
git merge feature

Workshop 15
● Initial git repo
○ add blank readme.txt and index.php
● Branch new feature from master call feature then
○ update index.php with some function
● Change branch to master
○ update readme.txt
● Change branch to feature
○ merge changes from base
● Change branch to master
○ merge feature to master

Git reflog
Git keeps track of updates to the tip of branches using a
mechanism called reflog.
git reflog
git reflog --relative-date

Example
git reflog
12aeb71 HEAD@{0}: merge feature: Fast-forward
df6c71f HEAD@{1}: reset: moving to df6c71f
12aeb71 HEAD@{2}: merge feature: Fast-forward
df6c71f HEAD@{3}: checkout: moving from feature to master

Example
git reflog --relative-date
12aeb71 HEAD@{9 minutes ago}: merge feature: Fast-forward
df6c71f HEAD@{11 minutes ago}: reset: moving to df6c71f
12aeb71 HEAD@{13 minutes ago}: merge feature: Fast-forward
df6c71f HEAD@{14 minutes ago}: checkout: moving from
feature to master

Workshop 16
Use git reflog to see changes and reset to any commit
revision.

Remote Repositories
Git’s collaboration model, which gives every developer their
own copy of the repository, complete with its own local
history and branch structure. Instead of committing a
changeset from a working copy to the central repository, Git
lets you share entire branches between repositories.

Quick Git Server (1)
# install ssh server and git
sudo apt-get install openssh-server
sudo apt-get install git
# add git user for all users access
sudo adduser --group sudo git
# then import user’s public key to .ssh/authorized_keys
sudo su git
cd
mkdir .ssh
cat id_rsa.john.pub >> .ssh/authorized_keys

Quick Git Server (2)
# Make git repo dir at /git for easy access
sudo mkdir /git
sudo chown git:git /git
# Make share repo called project.git
sudo su git
cd /git
git init --bare project.git
# Disable git user to ssh to server
sudo usermod -s /usr/bin/git-shell git

Workshop 17
● Setup git server add following users (or your team)
○ John
○ Jessie
○ Jessica
● Create share project called webapps

Git remote
The git remote command lets you create, view, and delete
connections to other repositories.
git remote
git remote add <name> <url>

origin

Central
Repo

git remote rm <name>

John’s
Repo

Jess’s
Repo

Example
# on John’s computer
cd myproject
git init
git add .
git commit -m 'initial commit'
git remote add origin git@gitserver:/git/project.git
git push origin master

Example
# on John’s computer
git clone git@gitserver:/git/project.git myproject
cd myproject
touch README
git add README
git commit -am “add readme”

Workshop 18
● Lets John first commit following files to repository
○ README
○ LICENSE
○ CONTRIBUTOR
● Another users clone repository to their machine

Git fetch
The git fetch command imports commits from a remote
repository into your local repo.
git fetch <remote>
git fetch <remote> <branch>

Example
cd myproject
git init
git fetch origin
git checkout master
git merge origin/master

Workshop 19
● Lets Jessica create feature branch and commit to
repository
● Another users fetch feature branch from repository to
their machine

Git pull
The git pull command merge upstream changes into your
local repository, it’s combined git fetch and git merge in
single command.
git pull <remote>
git pull --rebase <remote>

Example
cd myproject
git init
git checkout master
git pull --rebase origin

Workshop 20
Create working repository in machine and add remote
repository and use git pull to merge remote repository to
working repository.

Git push
The git pull command merge upstream changes into your
local repository, it’s combined git fetch and git merge in
single command.
git push
git push <remote>

Example
echo “this is a readme” > README

origin

John’s
Repo

Central
Repo

Jess’s
Repo

Workshop 21
Create working repository in machine and add remote
repository and use git pull to merge remote repository to
working repository. Edit some file and push to remote
repository

Git Workflows
The possible workflows can make it hard to know where to
begin when implementing Git in the workplace. These
workflows are designed to be guidelines rather than
concrete rules.

Centralized Workflow
The Centralized Workflow uses a
central repository to serve as the
single point-of-entry for all changes to
the project. Instead of trunk, the
default development branch is called
master and all changes are committed
into this branch.

Example
# Initialized central repository on server
git init --bare /part/to/repo.git

Example
# developer clone from repository
git clone ssh://user@host/path/to/repo.git

Example
# John done his feature
git status
git add
git commit

Example
# Jessie try to push her feature
# Git will refuse the request with a rather
verbose error message. She needs to pull
John’s updates into her repository, integrate
them with her local changes, and then try
again.

Example
# Jessie rebase on top of John’s commit
git pull --rebase origin master

Example
# Jessie and John working on relate feature
rebasing process will generate conflicts
git status
git add <somefile>
git rebase --continue
# If you get to this point and you have no idea what’
s going on, don’t panic. Just execute following
command and you’ll be right back.
git rebase --abort

Example
# Jessie successfully push her feature

Workshop 22
●
●
●
●

Group 2-3 people
Setup your team git repository server.
Use centralized workflow to fix code in sample application.
Sample application can pull from https://github.
com/anoochit/git-workshop.git

Feature Branch Workflow
the Centralized Workflow, adding feature branches to your
development process is an easy way to encourage
collaboration and streamline communication between
developers.

Example
# clone from repository
git clone ssh://user@host/path/to/repo.git

Example
# Jessie branch new feature
git checkout -b jessie-feature master

git status
git add <some-file>
git commit

Example
# Jessie push her feature
git push -u origin jessie-feature

Example
# Jessie push her feature to remote repository
git push

Example
# John is ready to accept the pull request,
someone needs to merge the feature into the
stable project (this can be done by either John
or Jessie):
git checkout master
git pull
git pull origin jessie-feature
git push

Workshop 23
●
●
●
●

Group 2-3 people
Use feature branch workflow to fix code in sample application.

Git Flow Workflow
The Gitflow Workflow defines a strict branching model
designed around the project release. While somewhat more
complicated than the Feature Branch Workflow, this
provides a robust framework for managing larger projects.

v0.1

Master

Developer

Feature

v0.2

v0.3

v0.4

v0.1

Master

Developer

Feature

Release

v0.2

v0.3

v1.0

Example
# Jessie create development branch from master
git checkout -b develop master
git push -u origin developer

Example
# John add new feature
git checkout -b feature developer
git status
git add <file>
git commit

Example
# John ready to merge feature to development
git pull origin developer
git checkout developer
git merge feature
git push
git branch -d feature

Example
# Jessie prepare release
git checkout -b release-1.0 develop
git checkout master
git merge release-1.0
git tag -a 0.1 -m "Initial public release" master
git push --tags
git branch -d release-1.0

Example
# Discover some bugs
git checkout -b issue-123 master
# Fix some bugs
git checkout master
git merge issue-123
git push
git branch -d issue-123

Workshop 24
●
●
●
●

Group 2-3 people
Use git flow workflow to fix code in sample application.

Forking Workflow
The Forking Workflow is fundamentally different than the other
workflows Instead of using a single server-side repository to act as the
“central” codebase, it gives every developer a server-side repository.
Each contributor has not one, but two Git repositories: a private local
and a public server-side.

Example
Project maintainer initialized official repository
git init --bare /part/to/repo.git

Official

Example
Another developers clone (fork) official repository.
git clone user@gitserver/user/repo.git

John

Official

Jessie

Example
Developer clone their own repository
git remote add upstream user@gitserver/user/repo.git

Example
Developer work their features
git checkout -b feature
# Edit some code
git commit -am “add feature”

Example
Developer publish their features
git push origin feature

Example
Project maintainer integrate their feature
1. Inspect the code
2. Pull code in local repository and
manually merge
git fetch user@gitserver/user/repo.git feature
# Inspect code
git checkout master
git merge FETCH_HEAD

Example
Developers synchronized with official
repository, the main codebase has moved
forward, other developers should
synchronize with the official repository
git pull upstream master

Workshop 25
●
●
●
●

Group 2-3 people
Setup your own git repository servers.
Use forking workflow to fix code in sample application.

Workshop 26
Discussion in your developer team, choose workflow or mix and match
your developer team. Present your idea, workflow to another groups

Future study
●
●
●
●
●

Git GUI Client
Git & GitHub Foundations Training
Git Documentation
Git Tutorial
Pro Git Book

Collaborative development with Git | Workshop

Collaborative development with Git | Workshop

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Collaborative development with Git | Workshop

Similar to Collaborative development with Git | Workshop (20)

More from Anuchit Chalothorn

More from Anuchit Chalothorn (20)

Recently uploaded

Recently uploaded (20)

Collaborative development with Git | Workshop