Source Control Management with

1. SOURCE CONTROL
MANAGEMENT
With Git

2. BUT WAIT!

3. TEXT EDITOR AND SHELL
Some Editors The Shell
Sublime Text 2 Git Bash
Komodo Edit Terminal
Coda (Mac) ssh
Text Wrangler (Mac)
PSPad (Win)
TextEdit (Win)

4. IMPORTANT PRE-CLASS LINKS
http:// bit.ly/gdiscm

5. MARKDOWN QUICK GUIDE
# Level 1 Header (h1) This is *italic*. (em)
## Level 2 Header (h2) This is **bold**. (strong)
##### Level 5 Header (h5)
This links to
Line breaks must have [Google](http://google.com)
two spaces at the end of the line.
* First Item
Paragraphs are separated by a blank line. * Second Item
* Third Item
Indent code blocks
with four spaces!

6. TRADITIONAL INTRO
begins here…

7. ABOUT ME
Owen Winkler
Twitter: @ringmaster
Email: ringmaster@midnightcircus.com
GitHub: https://github.com/ringmaster

8. TODAY’S PLAN
1. Basics of SCM
2. Starting a Project
3. Branching and Experimentation
4. GitHub and Remotes
5. Conflict Resolution
6. (Maybe) Using Submodules

9. WHAT IS SCM?
aka “Revision Control”

10. THE CURRENT STATE OF THINGS

11. WHAT IS SCM?
Revision control, also known as version
control and source control is the management of
changes to documents, computer programs, large web
sites, and other collections of information.
~ Wikipedia

12. ADVANTAGES OF SCM
• Resilience
• Collaboration
• Efficiency
• Accountability
• Integration

13. VOCABULARY
Working Copy Remote
Production Pull/Push
Repository Merge
Stage Conflict
Commit Resolve
Revert Hash
Head
Branch
Master
Tag

14. THE GIT PROCESS

15. THE GIT PROCESS

16. THE GIT PROCESS

17. THE GIT PROCESS

18. THE GIT PROCESS

19. SHELL BASICS
The Bare Minimum

20. COMMANDS YOU SHOULD KNOW
ls List the contents of a directory
ls -la List ALL the contents of a directory (hidden files, times, sizes)
cd xx Change to the directory “xx”
cd .. Change to the directory above this one
cd ~ Change to your home directory
cd / Change to the directory at the root of your computer
mkdir Make a directory
pwd -P Show the full path of the current directory
[letter][tab] Autocomplete or show all possibilities
[up-arrow] Use the last command in your history

21. OTHER USEFUL COMMANDS
[Ctrl]+R Search for a previously used command
history List the last 100 or so commands you used
alias l="ls -la" Assign the command “l” to do “ls -la”
mv xx yy Rename/move the file “xx” as “yy”
rm xx Delete the file named “xx”
rmdir xx Delete the empty directory named “xx”

22. LET’S MAKE A FILE
Step 1 Step 2
• Change to the user directory • Find the directory you created in
• Make a directory for this class Finder/Explorer
• Change to the class directory • Create a file called
“contributors.txt”
• Create a directory called “names”
• Edit that file in your editor
• Change to that directory
• Add your name to the file
Do not create the directory
using Finder/Explorer/your
editor!

23. HERE COMES THE FUN PART
Starting with git

24. CENTRALIZED
VERSION CONTROL
Some
Central
Server
My
Computer

25. DISTRIBUTED
VERSION CONTROL
My
Computer

26. CREATE A REPO
Configure Git Global Settings
• Set your git username
git config --global user.name "github-user-name"
• Set your git email address
git config --global user.email "github-email“
• Set your git editor
Mac: git config --global core.editor "nano"
Windows: Use GitPad
Procedure
• Change to the working directory
• Initialize the repo
git init

28. GIT STATUS
Files can have (in general) 4 states:
• Untracked
• Tracked
• Changed
• Staged

30. GIT ADD/STAGE
We need a way to stage things to be committed.
Committing is an “all at once” action.
Procedure
• Add the contributors.txt file to stage it.
git add contributors.txt
• Check the status of the working directory.
git status

32. COMMIT
Commit changes to the repo.
All staged changes are committed at once.
Every commit is stored in the repo with a “hash”.
Procedure
• Commit all staged changes
git commit

34. LET’S MAKE A CHANGE
Procedure
• Get neighbor’s name and why they’re here
• Add neighbor’s name to your editor (It’s still open, right?)
• Save the file with the added name
• Check the status of your working directory
git status
• Add the file to be staged
git add contributors.txt
• commit the changes to your repo
git commit

35. INTERLUDE
Isn’t this exciting?

36. GIT STASH
Stash is the coolest feature ever.
Stash allows you to make other changes mid-change.
Procedure
• While you still have changes… DO NOT COMMIT!
• Instead, stash your changes
git stash
• Then make your change, add, and commit as normal
git add; git commit
• Then pop your change off the stash
git stash pop

37. INTERLUDE
Isn’t this exciting?

38. GIT DIFF
For when you ask yourself,
Hey, wait a minute, what did I change? ?
Procedure
• Use Diff to see what is currently changed, but not yet staged
git diff
• Use Diff to see what is staged, but not yet committed
git diff –cached
• Use Diff to see the differences between your working copy
and the last commit
git diff HEAD

41. GIT LOG
Use the log to see what you and others have been adding to your repo.
Procedure
• Use git log to see all changes in your current branch
git log
• Use --oneline to see each change in the log on one line
git log –oneline
• Use the hashes shown in the log to get the diff between two commits
git diff

43. INTERLUDE
Isn’t this exciting?

44. GIT REBASE
This is the “What the heck?” git command.
Rebase allows you to combine a bunch of commits into one that makes you
look less like a freakish commit-crazy idiot.
Procedure
• Use rebase to interactively select from the last 5 small commits
to combine into one big commit
git rebase –I HEAD~5

46. INTERLUDE
Isn’t this exciting?

47. BRANCHING
Branching allows you to get experimental.
You can leave the state of master alone, and work solely on your branch.
Process
• Create a new branch
git branch markdownlist
• Checkout the branch you want to work on
git checkout markdownlist
• OR Create a new branch and switch to using it all in one step
git checkout -b markdownlist
• Then list the branches that are available
git branch
git branch -v

50. ADD THAT LIST
Asterisks aplenty

51. SWITCHING BETWEEN
BRANCHES
Branches track their own change history.
Switching between branches changes
only the unmodified, tracked files in your working copy.
Procedure
• Check with branch you are on
git status
• Checkout the master branch
git checkout master
• Verify that you’re on the master branch
git status

53. REINTEGRATING BRANCHES
If the changes in a branch need to be copied into the master branch, they
should be merged.
Merging is usually a scary word.
Procedure
• Checkout the branch that the new code should be moved to
git checkout master
• Merge the branch into the current branch
git merge markdownlist

55. FEATURE BRANCHES
Development teams use Feature Branches for different purposes.

57. TAGGING
Tagging marks a specific commit with a name, and optionally annotates it.
Procedure
• Use git tag to create a lightweight tag of the current branch at HEAD
git tag version1
• OR, Use the -a flag to annotate the tag
git tag -a version 1 -m "My message"
• Use git show to see the commit of the tag
git show version1

59. GITHUB
A central git website

60. SSH KEYPAIRS
SSH is the method Github uses to securely exchange data.
Public Keys are the means that Github uses to authenticate.
We must create a key pair to authenticate ourselves to Github.

64. CREATE A REPO
On Github!

65. INITIALIZE A REPO FROM
SCRATCH ON GITHUB
Using the instructions to get a repo from Github.
Procedure
• Create the repo on Github
• Follow the instructions to create an empty repo
git init; git add; git commit
• Connect the repo to Github
git remote add origin
git@github.com:ringmaster/scm.git
• Push the repo to Github
git push –u origin master

69. GIT PUSH
After you’ve completed a commit that you want to share,
push your commits to the remote repository.
Procedure
• Finalize any commits (modified or untracked files won’t be pushed!)
• Execute git push on your repo
git push origin master

71. GIT PULL
When you want to update your working copy from the remote repository,
use git pull.
Procedure
• Commit or stash any changes (git won’t let you pull over modified files!)
• Execute git pull on your repo
git pull origin master

73. ADDING A NEW REMOTE
Let’s try creating a new repo on Github for our contributors.txt file repo, and
then pushing to that remote.
Procedure
• Create a new repo on Github
• Add the repo URL (ssh) as a remote on the existing working copy
git remote add origin
git@github.com:ringmaster/contrib.git
• Push the repo to Github
git push –u origin master

75. CLONING EXISTING REPOS
This is the fun part

76. CLONING
When there is an existing repo on Github that you would like to work on as
your working copy, you clone it.
Procedure
• Copy the git URL from the Github page (use the ssh version)
• Execute git clone where you want to create your new working copy
git clone git@github.com:ringmaster/fob.git

78. CONFLICT RESOLUTION
No, this is the fun part

79. HERE WE GO…
https://github.com/ringmaster/gdiscm

80. OWEN’S IMMUTABLE
LAWS OF SCM
• If you run blame, you’re most likely to find that you’re the one at fault.
• Commit whenever you feel like you’ve reached a point that you’re
complete, even (especially) if you might immediately rewrite the whole
thing.

81. RESOURCES
http://git-scm.com/about