Tracking Changes¶
Objectives
- Go through the modify-add-commit cycle for one or more files.
- Explain where information is stored at each stage of that cycle.
- Distinguish between descriptive and non-descriptive commit messages.
First let's make sure we're still in the right directory.
You should be in the vc_project directory.
Let's create a file called README.txt that contains some notes
about the variant calling workflow.
We'll use nano to edit the file;
you can use whatever editor you like.
In particular, this does not have to be the core.editor you set globally earlier. But remember, the bash command to create or edit a new file will depend on the editor you choose (it might not be nano). For a refresher on text editors, check out "Which Editor?" in The Unix Shell lesson.
Type the text below into the README.txt file:
Let's first verify that the file was properly created by running the list command (ls):
README.txt contains a single line, which we can see by running:
If we check the status of our project again, Git tells us that it's noticed the new file:
code
The "untracked files" message means that there's a file in the directory
that Git isn't keeping track of.
We can tell Git to track a file using git add:
and then check that the right thing happened:
code
Git now knows that it's supposed to keep track of README.txt,
but it hasn't recorded these changes as a commit yet.
To get it to do that,
we need to run one more command:
code
When we run git commit,
Git takes everything we have told it to save by using git add
and stores a copy permanently inside the special .git directory.
This permanent copy is called a commit
(or revision) and its short identifier is f22b25e. Your commit may have another identifier.
We use the -m flag (for "message")
to record a short, descriptive, and specific comment that will help us remember later on what we did and why.
If we just run git commit without the -m option,
Git will launch nano (or whatever other editor we configured as core.editor)
so that we can write a longer message.
Good commit messages start with a brief (\<50 characters) statement about the
changes made in the commit. Generally, the message should complete the sentence "If applied, this commit will"
If we run git status now:
it tells us everything is up to date.
If we want to know what we've done recently,
we can ask Git to show us the project's history using git log:
code
git log lists all commits made to a repository in reverse chronological order.
The listing for each commit includes
the commit's full identifier
(which starts with the same characters as
the short identifier printed by the git commit command earlier),
the commit's author,
when it was created,
and the log message Git was given when the commit was created.
Where Are My Changes?
If we run ls at this point, we will still see just one file called README.txt.
That's because Git saves information about files' history
in the special .git directory mentioned earlier
so that our filesystem doesn't become cluttered
(and so that we can't accidentally edit or delete an old version).
Now suppose Dracula adds more information to the file.
(Again, we'll edit with nano and then cat the file to show its contents;
you may use a different editor, and don't need to cat.)
code
When we run git status now,
it tells us that a file it already knows about has been modified:
code
The last line is the key phrase:
"no changes added to commit".
We have changed this file,
but we haven't told Git we will want to save those changes
(which we do with git add)
nor have we saved them (which we do with git commit).
So let's do that now. It is good practice to always review
our changes before saving them. We do this using git diff.
This shows us the differences between the current state
of the file and the most recently saved version:
code
The output is cryptic because
it is actually a series of commands for tools like editors and patch
telling them how to reconstruct one file given the other.
If we break it down into pieces:
- The first line tells us that Git is producing output similar to the Unix
diffcommand comparing the old and new versions of the file. - The second line tells exactly which versions of the file
Git is comparing;
df0654aand315bf3aare unique computer-generated labels for those versions. - The third and fourth lines once again show the name of the file being changed.
- The remaining lines are the most interesting, they show us the actual differences
and the lines on which they occur.
In particular,
the
+marker in the first column shows where we added a line.
After reviewing our change, it's time to commit it:
code
Whoops:
Git won't commit because we didn't use git add first.
Let's fix that:
code
Git insists that we add files to the set we want to commit before actually committing anything. This allows us to commit our changes in stages and capture changes in logical portions rather than only large batches. For example, suppose we're adding a few citations to relevant research to our thesis. We might want to commit those additions, and the corresponding bibliography entries, but not commit some of our work drafting the conclusion (which we haven't finished yet).
To allow for this, Git has a special staging area where it keeps track of things that have been added to the current changeset but not yet committed.
Staging Area
If you think of Git as taking snapshots of changes over the life of a project,
git add specifies what will go in a snapshot
(putting things in the staging area),
and git commit then actually takes the snapshot, and
makes a permanent record of it (as a commit).
If you don't have anything staged when you type git commit,
Git will prompt you to use git commit -a or git commit --all,
which is kind of like gathering everyone to take a group photo!
However, it's almost always better to
explicitly add things to the staging area, because you might
commit changes you forgot you made. (Going back to the group photo simile,
you might get an extra with incomplete makeup walking on
the stage for the picture because you used -a!)
Try to stage things manually,
or you might find yourself searching for "git undo commit" more
than you would like!
Let's watch as our changes to a file move from our editor to the staging area and into long-term storage. First, we'll add another line to the file:
code
code
So far, so good:
we've added one line to the end of the file
(shown with a + in the first column).
Now let's put that change in the staging area
and see what git diff reports:
There is no output: as far as Git can tell, there's no difference between what it's been asked to save permanently and what's currently in the directory. However, if we do this:
code
it shows us the difference between the last committed change and what's in the staging area. Let's save our changes:
code
check our status:
and look at the history of what we've done so far:
Terminal-2
commit 005937fbe2a98fb83f0ade869025dc2636b4dad5 (HEAD -> main)
Author: Vlad Dracula <vlad@tran.sylvan.ia>
Date: Thu Aug 22 10:14:07 2013 -0400
add alignment step
commit 34961b159c27df3b475cfe4415d94a6d1fcd064d
Author: Vlad Dracula <vlad@tran.sylvan.ia>
Date: Thu Aug 22 10:07:21 2013 -0400
Add first step of workflow
commit f22b25e3233b4645dabd0d81e651fe074bd8e73b
Author: Vlad Dracula <vlad@tran.sylvan.ia>
Date: Thu Aug 22 09:51:46 2013 -0400
Start notes project
Word-based diffing
Sometimes, e.g. in the case of the text documents a line-wise
diff is too coarse. That is where the --color-words option of
git diff comes in very useful as it highlights the changed
words using colors.
Paging the Log
When the output of git log is too long to fit in your screen,
git uses a program to split it into pages of the size of your screen.
When this "pager" is called, you will notice that the last line in your
screen is a :, instead of your usual prompt.
- To get out of the pager, press Q.
- To move to the next page, press Spacebar.
- To search for
some_wordin all pages, press / and typesome_word. Navigate through matches pressing N.
Limit Log Size
To avoid having git log cover your entire terminal screen, you can limit the
number of commits that Git lists by using -N, where N is the number of
commits that you want to view. For example, if you only want information from
the last commit you can use:
code
You can also reduce the quantity of information using the
--oneline option:
code
You can also combine the --oneline option with others. One useful
combination adds --graph to display the commit history as a text-based
graph and to indicate which commits are associated with the
current HEAD, the current branch main, or
other Git references:
Directories
Two important facts you should know about directories in Git.
- Git does not track directories on their own, only files within them. Try it for yourself:
Note, our newly created empty directory scripts does not appear in
the list of untracked files even if we explicitly add it (via git add) to our
repository. This is the reason why you will sometimes see .gitkeep files
in otherwise empty directories. Unlike .gitignore, these files are not special
and their sole purpose is to populate a directory so that Git adds it to
the repository. In fact, you can name such files anything you like.
- If you create a directory in your Git repository and populate it with files, you can add all files in the directory at once by:
Try it for yourself:
Before moving on, we will commit these changes.
To recap, when we want to add changes to our repository,
we first need to add the changed files to the staging area
(git add) and then commit the staged changes to the
repository (git commit):
Choosing a Commit Message
Which of the following commit messages would be most appropriate for the
last commit made to README.txt?
- "Changes"
- "Added line '1. Perform QC' to README.txt"
- "Add first step of workflow"
Solution
Answer 1 is not descriptive enough, and the purpose of the commit is unclear; and answer 2 is redundant to using "git diff" to see what changed in this commit; but answer 3 is good: short, descriptive, and imperative.
Committing Changes to Git
Which command(s) below would save the changes of myfile.txt
to my local Git repository?
-
bash $ git commit -m "my recent changes" -
bash $ git init myfile.txt $ git commit -m "my recent changes" -
bash $ git add myfile.txt $ git commit -m "my recent changes" -
bash $ git commit -m myfile.txt "my recent changes"
Solution
- Would only create a commit if files have already been staged.
- Would try to create a new repository.
- Is correct: first add the file to the staging area, then commit.
- Would try to commit a file "my recent changes" with the message myfile.txt.
Committing Multiple Files
The staging area can hold changes from any number of files that you want to commit as a single snapshot.
- Add a step 3 to
README.txt - Create a new file
metadata.txtwith a very brief description of the dataset - Add changes from both files to the staging area, and commit those changes.
Solution
The output below from cat README.txt reflects only content added during
this exercise. Your output may vary.
First we make our changes to the README.txt and venus.txt files:
code
Now you can add both files to the staging area. We can do that in one line:
Or with multiple commands:
Now the files are ready to commit. You can check that using git status. If you are ready to commit use:
bio Repository
- Create a new Git repository on your computer called
bio. - Write a three-line biography for yourself in a file called
me.txt, commit your changes - Modify one line, add a fourth line
- Display the differences between its updated state and its original state.
Solution
If needed, move out of the planets folder:
Create a new folder called bio and 'move' into it:
Initialise git:
Create your biography file me.txt using nano or another text editor.
Once in place, add and commit it to the repository:
Modify the file as described (modify one line, add a fourth line).
To display the differences
between its updated state and its original state, use git diff:
!!! info Keypoints"
- `git status` shows the status of a repository.
- Files can be stored in a project's working directory (which users see), the staging area (where the next commit is being built up) and the local repository (where commits are permanently recorded).
- `git add` puts files in the staging area.
- `git commit` saves the staged content as a new commit in the local repository.
- Write a commit message that accurately describes your changes.