Sharing your work on GitHub

When we have logged in to GitHub, we will see an option to create a new repository. Let’s make one for the GitHub experiments we are going to do today. 

• new repository

• give it a name

$ git remote add origin <web address of your repo.git>

This will add a repository on GitHub for our changes to be committed to.

Check that it is set up correctly with the command: 

$ git remote -v
origin	<web address of your repo.git> (fetch)
origin	<web address of your repo.git> (push)

Then enter:

$ git push -u origin master

git push

git push will add the changes made in our local repository to the repository on GitHub. The nickname of our remote is origin and the default local branch name is master. The -u flag tells Git to remember the parameters, so that next time we can simply run git push and Git will know what to do. Go ahead and push it!

You will be prompted to enter your GitHub username and password to complete the command.

When we do a git push, we will see Git ‘pushing’ changes upstream to GitHub. Because our file is very small, this won’t take long but if we had made a lot of changes or were adding a very large repository, we might have to wait a little longer. We can get to see where we’re at with git status.

$ git status
On branch master
Your branch is up-to-date with 'origin/master'.

nothing to commit, working directory clean

This is letting us know where we are working (the master branch). We can also see that we have no changes to commit and everything is in order.

We can use git diff to see changes we have made before making a commit. Let’s add another line to our text file.

$ open git_test.txt
$ git diff 
diff --git a/git_test.txt b/git_test.txt
index 70c379b..1d55e1a 100644
--- a/git_test.txt
+++ b/git_test.txt
@@ -1 +1,2 @@
-Hello world
\ No newline at end of file
+Hello world
+More changes to my first github file
\ No newline at end of file

We can see the changes we have made.

1. The first line tells us that Git is producing output similar to the Unix diff command comparing the old and new versions of the file.
2. The second line tells exactly which versions of the file Git is comparing; df0654a and 315bf3a are unique computer-generated identifiers for those versions.
3. The third and fourth lines once again show the name of the file being changed.
4. The remaining lines are the most interesting; they show us the actual differences and the lines on which they occur. In particular, the + markers in the first column show where we have added lines. 

We can now commit these changes again: 

$ git add git_test.txt
$ git commit -m 'second line of changes'

Say we are very forgetful and have already forgotten what we changes we have made. git log allows us to look at what we have been doing to our Git repository (in reverse chronological order, with the very latest changes first). 

$ git status
commit 40d3f7af25e19c06fa839a570d51e38fdb374e80
Author: davanstrien <email@gmail.com>
Date:   Sun Oct 18 15:25:19 2015 +0100
    second line of changes
commit 27c3f19c3340d930234d592928b11b63403d0696
Author: davanstrien <email@gmail.com>
Date:   Sun Oct 18 13:27:31 2015 +0100
    hello world

This shows us the two commits we have made and shows the messages we wrote. It is important to try to use meaningful commit messages when we make changes. This is especially important when we are working with other people who might not be able to guess as easily what our short cryptic messages might mean.

git pull

We can try to see how this works by making changes on the GitHub website and then ‘pulling’ them back to our computer. 

Let’s go to our repository. We can see our txt file and make changes. However, you may have noticed only our first change is there. This is because we didn’t push our last commit yet. This might seem like a mistake in design but it is often useful to make a lot of commits for small changes so you are able to make careful revisions later and you don’t necessarily want to push all these changes one by one.

Let’s go back and push our changes

$ git push

Now if we go back to our GitHub repo, we can see all our changes. In the GitHub repo website, let’s add an extra line of text there, and commit these changes. When we commit changes on GitHub itself, we don’t have to push these.

Now let’s get the third line on to our computer.

$ git pull
remote: Counting objects: 3, done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), done.
From https://github.com/davanstrien/git_lesson_example
   40d3f7a..ef95e51  master     -> origin/master
Updating 40d3f7a..ef95e51
Fast-forward
 git_test.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

 If we open our text file again 

$ open git_test.txt

we can see our new lines from the GitHub website. 

When we begin collaborating on more complex projects, we may have to consider more aspects of Git functionality, but this should be a good start. 

Review & Exercises

(If time) Exercise - create a branch of the workshop repository and push your changes

Branches are a helpful way in a git repository to create a repository-local copy of the data in a new tracking space, add updates for a particular issue, then eventually merge that branch back with the master or main working branch.

Alone or in small groups, try pulling the workshop repository to your local computer, creating a new branch, adding some changes, then pushing those changes in that new branch back to the GitHub repository. The steps are below; see if you can start to pick up what they do:

# Change into the Home Directory
$ cd 
# Change into the Desktop (or wherever you're putting your workshop materials)
$ cd Desktop/
# Create & move into a new directory for our GitHub experiment
$ mkdir github-branch-experiment
$ cd github-branch-experiment
# clone the Workshop GitHub Repository to our local machine
$ git clone https://github.com/cmh2166/CUL-MWG-Workshop.git
  Cloning into 'CUL-MWG-Workshop'...
  remote: Counting objects: 74, done.
  remote: Compressing objects: 100% (54/54), done.
  remote: Total 74 (delta 16), reused 69 (delta 13), pack-reused 0
  Unpacking objects: 100% (74/74), done.
# Move into the Git repository we just cloned locally.
$ cd CUL-MWG-Workshop/
# Check out the current branch (there is only 1)
$ git branch
  * master
# create a new branch - your uni then '_branch'
$ git branch cmh329_branch
$ git checkout cmh329_branch
  Switched to branch 'cmh329_branch'
# touch is a bash command to create a new, empty file.
$ touch my_new_file.txt
# add some text to that new file.
$ echo "Hey new text file, how are you." >> my_new_file.txt 
# add that new file to our git repository, then commit it.
$ git add .
$ git commit -m 'I added my new text file for a test'
  [cmh329_branch d55367e] I added my new text file for a test
   1 file changed, 1 insertion(+)
  create mode 100644 my_new_file.txt
# push our changes back to GitHub, but creating our new branch remotely as well
# you'll need to alert Christina to your GitHub username so she can add you to it
# for this to work
$ git push origin cmh329_branch
  Counting objects: 3, done.
  Delta compression using up to 4 threads.
  Compressing objects: 100% (2/2), done.
  Writing objects: 100% (3/3), 333 bytes | 0 bytes/s, done.
  Total 3 (delta 1), reused 0 (delta 0)
  remote: Resolving deltas: 100% (1/1), completed with 1 local objects.
  To https://github.com/cmh2166/CUL-MWG-Workshop.git
   * [new branch]      cmh329_branch -> cmh329_branch
# Go to GitHub and see if you can find your new branch.