source control management

Post on 06-May-2015

917 Views

Category:

Documents

1 Downloads

Preview:

Click to see full reader

DESCRIPTION

Source Control Management with

TRANSCRIPT

With Git

SOURCE CONTROL MANAGEMENT

BUT WAIT!

Some EditorsSublime Text 2

Komodo Edit

Coda (Mac)

Text Wrangler (Mac)

PSPad (Win)

TextEdit (Win)

The ShellGit Bash

Terminal

ssh

TEXT EDITOR AND SHELL

http://bit.ly/gdiscm

IMPORTANT PRE-CLASS LINKS

# Level 1 Header (h1)

## Level 2 Header (h2)

##### Level 5 Header (h5)

Line breaks must have

two spaces at the end of the line.

Paragraphs are separated by a blank line.

Indent code blocks

with four spaces!

This is *italic*. (em)

This is **bold**. (strong)

This links to [Google](http://google.com)

* First Item

* Second Item

* Third Item

MARKDOWN QUICK GUIDE

TRADITIONAL INTRObegins here…

Owen WinklerTwitter: @ringmasterEmail: ringmaster@midnightcircus.comGitHub: https://github.com/ringmaster

ABOUT ME

1.Basics of SCM2.Starting a Project

3.Branching and Experimentation

4.GitHub and Remotes5.Conflict Resolution

6.(Maybe) Using Submodules

TODAY’S PLAN

WHAT IS SCM?aka “Revision Control”

THE CURRENT STATE OF THINGS

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

WHAT IS SCM?

• Resilience• Collaboration• Efficiency

• Accountability• Integration

ADVANTAGES OF SCM

Working Copy

Production

Repository

Stage

Commit

Revert

Head

Branch

Master

Tag

Remote

Pull/Push

Merge

Conflict

Resolve

Hash

VOCABULARY

THE GIT PROCESS

THE GIT PROCESS

THE GIT PROCESS

THE GIT PROCESS

THE GIT PROCESS

SHELL BASICSThe Bare Minimum

ls

ls -la

cd xx

cd ..

cd ~

cd /

mkdir

pwd -P

[letter][tab]

[up-arrow]

List the contents of a directory

List ALL the contents of a directory (hidden files, times, sizes)

Change to the directory “xx”

Change to the directory above this one

Change to your home directory

Change to the directory at the root of your computer

Make a directory

Show the full path of the current directory

Autocomplete or show all possibilities

Use the last command in your history

COMMANDS YOU SHOULD KNOW

[Ctrl]+R

history

alias l="ls -la"

mv xx yy

rm xx

rmdir xx

Search for a previously used command

List the last 100 or so commands you used

Assign the command “l” to do “ls -la”

Rename/move the file “xx” as “yy”

Delete the file named “xx”

Delete the empty directory named “xx”

OTHER USEFUL COMMANDS

Step 1• Change to the user

directory• Make a directory for this

class• Change to the class

directory• Create a directory called

“names”• Change to that directory

Step 2• Find the directory you

created in Finder/Explorer

• Create a file called “contributors.txt”

• Edit that file in your editor

• Add your name to the file

LET’S MAKE A FILE

Do not create the directory using

Finder/Explorer/your editor!

HERE COMES THE FUN PARTStarting with git

CENTRALIZEDVERSION CONTROL

My Computer

SomeCentral Server

DISTRIBUTEDVERSION CONTROL

My Computer

Configure Git Global Settings• Set your git username

git config --global user.name "github-user-name"

• Set your git email addressgit config --global user.email "github-email“

• Set your git editorMac: git config --global core.editor "nano"Windows: Use GitPad

Procedure• Change to the working directory• Initialize the repo

git init

CREATE A REPO

Files can have (in general) 4 states:

• Untracked• Tracked• Changed• Staged

GIT STATUS

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

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

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

INTERLUDEIsn’t this exciting?

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 normalgit add; git commit

• Then pop your change off the stashgit stash pop

GIT STASH

INTERLUDEIsn’t this exciting?

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 stagedgit 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 commitgit diff HEAD

GIT DIFF

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 linegit log –oneline

• Use the hashes shown in the log to get the diff between two commits

git diff

INTERLUDEIsn’t this exciting?

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

INTERLUDEIsn’t this exciting?

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 ongit checkout markdownlist

• OR Create a new branch and switch to using it all in one stepgit checkout -b markdownlist

• Then list the branches that are availablegit branchgit branch -v

BRANCHING

ADD THAT LISTAsterisks aplenty

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 branchgit checkout master

• Verify that you’re on the master branchgit status

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

togit checkout master

• Merge the branch into the current branchgit merge markdownlist

FEATURE BRANCHES

Development teams use Feature Branches for different purposes.

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 HEADgit tag version1

• OR, Use the -a flag to annotate the taggit tag -a version 1 -m "My message"

• Use git show to see the commit of the taggit show version1

TAGGING

GITHUBA central git website

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.

SSH KEYPAIRS

CREATE A REPOOn Github!

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 Githubgit remote add origin

git@github.com:ringmaster/scm.git

• Push the repo to Githubgit push –u origin master

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

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

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 copygit remote add origin

git@github.com:ringmaster/contrib.git

• Push the repo to Githubgit push –u origin master

CLONING EXISTING REPOSThis is the fun part

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 copygit clone git@github.com:ringmaster/fob.git

CONFLICT RESOLUTIONNo, this is the fun part

https://github.com/ringmaster/gdiscm

HERE WE GO…

• 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.

OWEN’S IMMUTABLE LAWS OF SCM

http://git-scm.com/about

RESOURCES

top related