Session 4 (12:00p - 2:00p)


  • Can you reset an individual file?

git checkout -- <filename>

git checkout HEAD -- source/

What’s the difference between

git checkout -- <filename>


git checkout HEAD -- <filename>

Nothing, HEAD is assumed.

  • Other questions on collaboration, binaries and design...

Netork Interactions

Everything begins locally in git then layers on things like remotes and collaboration.

Almost all activities happen offline. Offline activities have to be pushed to remotes.


four primary protocols: file, git, ssh, http.


git clone file:///path/to/project

git clone /path/to/project

cloning a local file is like checkout, but clone grabs all history for a repository.

file:///path/to/project fires up the ‘networking’ code within git whereas just /path/to/project looks directly at the filesystem.


git clone git://server/project.git

Almost always read-only. Can be made writable, but in most cases it’s read-only.

http (dumb)

git clone http://server/project.git

git clone https://server/project.git

Used to be the real differntiator between git and mercurial. Dumb version is insanely slow and inefficient.

https (smart)

Much faster and offers progress. Mostly handled on the server side.


Cloning and collaborating:

git clone

git branch evanculver

git push -u – tells git to track it.


Example of git’s speed by adding 3000 files and pushing them to remote.

After pushing, we can almost instantly get references to those files, but they’re just references.

git fetch origin git checkout thousands

When checking out, the state of the filesystem is being modified. By switching between the thousands branch and mine, > 3000 files are being created/destroyed

“Once mastered, the concepts of local, remote and upstream branches, the rest falls into place”

Local and remote live on your box.

Typing git fetch, your local cache is updated against what’s upstream or remote to you.

git fetch === git fetch origin


git push <remote>


0 collaboration up until this point. The integration point.

Combination: retrieves upstream objects and then merges and then commits merge to the local branch.

Excercise: Merging in remotes


git merge remotes/origin/chance

Pushing back up to remote:

git push

Reviewing any commits in the entire remotes tree:

git log -2 remotes/origin/chance


Simiply ‘bookmarks’ or pointers.

Origin is a remote you get by default.

git remote -v

Q: Why two entries? A: One inbound and one outbound. Almost always the same, but can be different in a very unique situation. For example, you may want to pull all code over ssh but push all over http.

Adding a remote

git remote add <remotename> <remotepath>

git remote add matthewongithub

note: Remote branches are locally immutable.

We have to make a local branch for anything we would like to change.

git checkout kenkil

Git is smart enough to know that you probably wanted to actually checkout the remote (remotes/origin/kenkil).

If you look at .git/config, you will see various [branch *] sections which define the remote/tracking portion of this.

Git will get mad if the branch name is ambiguous:

error: refspec... blah blah

git checkout -b <localbranch> --track remotes/origin/richzurad


git remote prune <remotename> – only removes old branches that no longer exist on the remote, has to be given an explicit remote name.

Diff’ing against remotes (or any two things)

git diff origin/ericg

git diff origin/ericg origin/richzurad

More exercises

<edit, add, commit>

git reset --soft HEAD~1

Tells git to roll back 1 commit, leaving the change in tact.

If you have already pushed, the game has changed entirely.

You can do the same as above, but force the push – the consequences of forcing the push causes the graph of the commits changes as your peers see them. Furthermore, you then have to ask what other people may be basing their work on. It may cause some really counter-intuitive output and attempts to merge in changes.

A better approach is to push another commit by ‘reverting’:

git revert <commithash> – Make a new commit that negates what was just committed. Always safe because it’s always forward moving which is exactly why forcing commits and changing history/graphi is usually always bad.