The document provides a comprehensive overview of Git, covering its advantages in version control such as performance, flexibility, and security features. It discusses various workflows for teams, including centralized and feature branch models, along with commands for repository management, branching, and merging. Best practices and additional resources for using Git effectively are also outlined.

1. GIT

2. MAYANK PATEL
APPLICATION ARCHITECT - OILDEX, A SERVICE OF TRANSZAP
/Linkedin @maxy_ermayank

3. What is Git?

4. Performance

5. Flexibility

6. Version control

7. Why Git?

8. Distributed Development

9. Faster Merge Cycle

10. Git for marketing

11. Git for product management

12. Git for designers

13. Git for customer support

14. Branching is Cheap

15. Git is the New Standard

16. Huge Community

17. Security

18. Encryption

19. Two factor authentication

20. Team permissions

21. Organization permissions

22. Fork permissions

23. LDAP/SAML/CAS

24. Audit - User actions

25. Audit - Git actions

26. Features

27. Code search

28. Pull requests

29. Inline editing

30. Markdown support

31. @mentions

32. Inline rendering of PDF les

33. Image diffs

34. Integration with plenty of tools

35. Tooling

36. Real Time Noti cation

37. History

38. Wiki

39. Social

40. Discussions

41. HipChat Integration

42. JIRA Integration

43. DEVELOPMENT INFO
Branch
Commit
Pull Request

45. Git & CI

46. Run builds from your feature branches

47. Git Work ows

48. Can we still x a bug for the Release?

49. How do we do Hot x for the current version?

50. Is the code for the Feature complete?

51. Has everyone reviewed the code for this feature?

52. Centralized
provides the closest match to common SVN
processes, so it's a good option to get started.

53. Git ow
A Git ow work ow is a more formal,
structured extension to feature branching,
making it a great option for larger teams with
well-de ned release cycles.

54. AdHoc

55. Forking (Public GitHub)
Finally, consider a forking work ow if you
need maximum isolation and control over
changes, or have many developers
contributing to one repository.

56. Feature Branch
Building on that idea, using a feature branch
work ow lets developers keep their work in
progress isolated and important shared
branches protected. Feature branches also
form the basis for managing changes via pull
requests.

57. A SUCCESSFUL GIT BRANCHING MODEL

60. Generating and Add SSH Key

61. Let's get to Work now

62. Create a new local repository
git init

63. Clone Repository

64. Create a working copy of a local repository
git clone /path/to/repository

65. For a remote server, use
git clone username@host:/path/to/repository

66. Remote

67. Connect to a remote repository
git remote add origin server

68. Create a new local repository
git remote -v

69. Remove Remote
git remote remove upstream

70. Staging Changes

71. Staging a le
git add lename

72. Staging all changes for commit
git add *
OR
git add -A

73. Staging changes on Directory path
git add .

74. Commit

75. Commit changes to head (but not yet to the remote
repository)
git commit -m “Commit message”

76. Commit any les you‘ve added with git add, and also commit
any les you’ve changed since then
git commit -a

78. Pull
git pull upstream branchname

79. Push
git push origin branchname

80. Status
git status

81. Branches

82. Create a new branch and switch to it
git checkout -b branchname

83. Switch from one branch to another
git checkout branchname

84. List all the branches in your repo, and also tell you what
branch you're currently in
git branch

85. List all the branches including remote branches in your repo,
and also tell you what branch you're currently in
git branch -a

86. Delete the feature branch
git branch -d branchname

87. Delete a branch on your remote repository
git push origin :branchname

88. Push the branch to your remote repository, so others can use
it
git push origin branchname

89. Push all branches to your remote repository
git push —all origin

90. Update from the remote repository

91. Fetch and merge changes on the remote server to your
working directory
git pull

92. To merge a different branch into your active branch
git merge branchname

93. View all the merge con icts:View the con icts against the
base le:Preview changes, before merging
git diff —base lename
git diff sourcebranch targetbranch

94. After you have manually resolved any con icts, you mark the
changed le
git add lename

95. Tags

96. You can use tagging to mark a signi cant changeset, such as a
release
git tag 1.0.0 commitID

97. CommitId is the leading characters of the changeset ID, up to
10, but must be unique. Get the ID using
git log

98. Push all tags to remote repository
git push —tags origin

99. Undo local changes

100. If you mess up, you can replace the changes in your working
tree with the last content in head:Changes already added to
the index, as well as new les, will be kept.
git checkout — lename

101. Instead, to drop all your local changes and commits, fetch the
latest history from the server and point your local master
branch at it, do this
git fetch origin git reset —hard origin/master

102. Search the working directory for foo()
git grep “foo()”

103. Other Usefull Commands
git rm
git mv
git diff
git log

105. .gitignore
Anything that not supposed to be in your
Repository should be added to .gitignore le

106. Glossary

107. Version Control

108. Repository

109. Fork
Full copy of main repo under your user space

110. Clone
Copy of Repo

111. Branch

112. Master
Release Candidates / Production ready code

113. Develop
Continuos Integration Branch (Unit Test,
Integration tests)

114. Pull Requests (To contribute your changes)

115. Merge

116. Tag

117. Working Tree

118. HEAD

119. Hook

120. Code Review

121. Maintainer

122. Reviewer

123. Contribute

124. Collaborator

125. Upstream

126. Work ow for us

127. Create Repository

128. Create Develop branch

129. Set Develop as default branch

130. Add Collaborator

131. Fork

132. Clone
git clone
git@github.*.com:mpatel/welcome.git

133. Add Remote Upstream
Check Remote (git remote -v)
git remote add upstream
git@github.*.com:mainOrganization/welcome.git
origin git@github.*.com:mpatel/welcome.git
(fetch) origin
git@github.*.com:mpatel/welcome.git (push)
upstream
git@github.*.com:mainOrganization/welcome.git
(fetch) upstream
git@github.*.com:mainOrganization/welcome.git
(push)

134. Fetch
git fetch upstream

135. Pull to update your local develop
git pull upstream develop

136. Check out a feature branch from develop
git checkout -b OPL1212KeepMeSignedIn

137. Do work in your feature branch, committing
early and more often

138. Stage changes with
commands
git add

139. Commit with
commands
git commit

140. Push
git push origin OPL1212KeepMeSignedIn

141. Create Pull Request from mpatel/welcome
OPL1212KeepMeSignedIn branch to
mainOrganization/welcome Develop branch

142. Review

143. Merge frequently to incorporate upstream
changes

144. Interactive merge

145. Merge your changes with Develop

146. Push your changes to the Upstream

147. Delete Feature Branch
git branch -D OPL1212KeepMeSignedIn

148. Push deleted branch from your remote copy
git push origin :OPL1212KeepMeSignedIn

151. Branching and Release Strategy

152. Feature Branches
Create Branch from Develop
Merge into Develop

153. Release Branches
Create Branch from Develop
Merge into Master and Develop

154. Hot x Branches
Create Branch from Master
Merge into Master and Develop

155. BEST PRACTICES
Use a descriptive commit message
Link Commits to Issues (Feature, Bug, Task)
Make each commit a logical unit
Incorporate others' changes frequently
Share your changes frequently
Don't commit generated les

156. RESOURCES
Pro Git
Try Git right in your web browser
Smart Commit commands
Online Training
Markdown Cheatsheet
GitHub Enterprise Resources
A successful Git branching model
GitHub Help
Git-SCM

157. Thank You!!!