Content from Automated Version Control
Last updated on 2023-11-14 | Edit this page
Estimated time 5 minutes
Overview
Questions
- What is version control and why should I use it?
Objectives
- Understand the benefits of an automated version control system.
- Understand the basics of how automated version control systems work.
We’ll start by exploring how version control can be used to keep track of what one person did and when. Even if you aren’t collaborating with other people, automated version control is much better than this situation:
We’ve all been in this situation before: it seems unnecessary to have multiple nearly-identical versions of the same document. Some word processors let us deal with this a little better, such as Microsoft Word’s Track Changes, Google Docs’ version history, or LibreOffice’s Recording and Displaying Changes.
Version control systems start with a base version of the document and then record changes you make each step of the way. You can think of it as a recording of your progress: you can rewind to start at the base document and play back each change you made, eventually arriving at your more recent version.
Once you think of changes as separate from the document itself, you can then think about “playing back” different sets of changes on the base document, ultimately resulting in different versions of that document. For example, two users can make independent sets of changes on the same document.
Unless multiple users make changes to the same section of the document - a conflict - you can incorporate two sets of changes into the same base document.
A version control system is a tool that keeps track of these changes for us, effectively creating different versions of our files. It allows us to decide which changes will be made to the next version (each record of these changes is called a commit), and keeps useful metadata about them. The complete history of commits for a particular project and their metadata make up a repository. Repositories can be kept in sync across different computers, facilitating collaboration among different people.
The Long History of Version Control Systems
Automated version control systems are nothing new. Tools like RCS, CVS, or Subversion have been around since the early 1980s and are used by many large companies. However, many of these are now considered legacy systems (i.e., outdated) due to various limitations in their capabilities. More modern systems, such as Git and Mercurial, are distributed, meaning that they do not need a centralized server to host the repository. These modern systems also include powerful merging tools that make it possible for multiple authors to work on the same files concurrently.
Paper Writing
Imagine you drafted an excellent paragraph for a paper you are writing, but later ruin it. How would you retrieve the excellent version of your conclusion? Is it even possible?
Imagine you have 5 co-authors. How would you manage the changes and comments they make to your paper? If you use LibreOffice Writer or Microsoft Word, what happens if you accept changes made using the
Track Changes
option? Do you have a history of those changes?
Recovering the excellent version is only possible if you created a copy of the old version of the paper. The danger of losing good versions often leads to the problematic workflow illustrated in the PhD Comics cartoon at the top of this page.
Collaborative writing with traditional word processors is cumbersome. Either every collaborator has to work on a document sequentially (slowing down the process of writing), or you have to send out a version to all collaborators and manually merge their comments into your document. The ‘track changes’ or ‘record changes’ option can highlight changes for you and simplifies merging, but as soon as you accept changes you will lose their history. You will then no longer know who suggested that change, why it was suggested, or when it was merged into the rest of the document. Even online word processors like Google Docs or Microsoft Office Online do not fully resolve these problems.
Content from Setting Up Git
Last updated on 2023-11-14 | Edit this page
Estimated time 5 minutes
Overview
Questions
- How do I get set up to use Git?
Objectives
- Configure
git
the first time it is used on a computer. - Understand the meaning of the
--global
configuration flag.
When we use Git on a new computer for the first time, we need to configure a few things. Below are a few examples of configurations we will set as we get started with Git:
- our name and email address,
- what our preferred text editor is,
- and that we want to use these settings globally (i.e. for every project).
On a command line, Git commands are written as
git verb options
, where verb
is what we
actually want to do and options
is additional optional
information which may be needed for the verb
. So here is
how Dracula sets up his new laptop:
BASH
$ git config --global user.name "Vlad Dracula"
$ git config --global user.email "vlad@tran.sylvan.ia"
Please use your own name and email address instead of Dracula’s. This user name and email will be associated with your subsequent Git activity, which means that any changes pushed to GitHub, BitBucket, GitLab or another Git host server after this lesson will include this information.
For this lesson, we will be interacting with GitHub and so the email address used should be the same as the one used when setting up your GitHub account. If you are concerned about privacy, please review GitHub’s instructions for keeping your email address private.
Line Endings
As with other keys, when you hit Enter or ↵ or on Macs, Return on your keyboard, your computer encodes this input as a character. Different operating systems use different character(s) to represent the end of a line. (You may also hear these referred to as newlines or line breaks.) Because Git uses these characters to compare files, it may cause unexpected issues when editing a file on different machines. Though it is beyond the scope of this lesson, you can read more about this issue in the Pro Git book.
You can change the way Git recognizes and encodes line endings using
the core.autocrlf
command to git config
. The
following settings are recommended:
On macOS and Linux:
BASH
$ git config --global core.autocrlf input
And on Windows:
BASH
$ git config --global core.autocrlf true
Dracula also has to set his favorite text editor, following this table:
Editor | Configuration command |
---|---|
Atom | $ git config --global core.editor "atom --wait" |
nano | $ git config --global core.editor "nano -w" |
BBEdit (Mac, with command line tools) | $ git config --global core.editor "bbedit -w" |
Sublime Text (Mac) | $ git config --global core.editor "/Applications/Sublime\ Text.app/Contents/SharedSupport/bin/subl -n -w" |
Sublime Text (Win, 32-bit install) | $ git config --global core.editor "'c:/program files (x86)/sublime text 3/sublime_text.exe' -w" |
Sublime Text (Win, 64-bit install) | $ git config --global core.editor "'c:/program files/sublime text 3/sublime_text.exe' -w" |
Notepad (Win) | $ git config --global core.editor "c:/Windows/System32/notepad.exe" |
Notepad++ (Win, 32-bit install) | $ git config --global core.editor "'c:/program files (x86)/Notepad++/notepad++.exe' -multiInst -notabbar -nosession -noPlugin" |
Notepad++ (Win, 64-bit install) | $ git config --global core.editor "'c:/program files/Notepad++/notepad++.exe' -multiInst -notabbar -nosession -noPlugin" |
Kate (Linux) | $ git config --global core.editor "kate" |
Gedit (Linux) | $ git config --global core.editor "gedit --wait --new-window" |
Scratch (Linux) | $ git config --global core.editor "scratch-text-editor" |
Emacs | $ git config --global core.editor "emacs" |
Vim | $ git config --global core.editor "vim" |
VS Code | $ git config --global core.editor "code --wait" |
It is possible to reconfigure the text editor for Git whenever you want to change it.
Exiting Vim
Note that Vim is the default editor for many programs. If you haven’t
used Vim before and wish to exit a session without saving your changes,
press Esc then type :q!
and hit Enter
or ↵ or on Macs, Return. If you want to save your
changes and quit, press Esc then type :wq
and
hit Enter or ↵ or on Macs, Return.
Git (2.28+) allows configuration of the name of the branch created
when you initialize any new repository. Dracula decides to use that
feature to set it to main
so it matches the cloud service
he will eventually use.
BASH
$ git config --global init.defaultBranch main
Default Git branch naming
Source file changes are associated with a “branch.” For new learners
in this lesson, it’s enough to know that branches exist, and this lesson
uses one branch.
By default, Git will create a branch called master
when you
create a new repository with git init
(as explained in the
next Episode). This term evokes the racist practice of human slavery and
the software development
community has moved to adopt more inclusive language.
In 2020, most Git code hosting services transitioned to using
main
as the default branch. As an example, any new
repository that is opened in GitHub and GitLab default to
main
. However, Git has not yet made the same change. As a
result, local repositories must be manually configured have the same
main branch name as most cloud services.
For versions of Git prior to 2.28, the change can be made on an
individual repository level. The command for this is in the next
episode. Note that if this value is unset in your local Git
configuration, the init.defaultBranch
value defaults to
master
.
The five commands we just ran above only need to be run once: the
flag --global
tells Git to use the settings for every
project, in your user account, on this computer.
Let’s review those settings and test our core.editor
right away:
BASH
$ git config --global --edit
Let’s close the file without making any additional changes. Remember, since typos in the config file will cause issues, it’s safer to view the configuration with:
BASH
$ git config --list
And if necessary, change your configuration using the same commands to choose another editor or update your email address. This can be done as many times as you want.
Proxy
In some networks you need to use a proxy. If this is the case, you may also need to tell Git about the proxy:
BASH
$ git config --global http.proxy proxy-url
$ git config --global https.proxy proxy-url
To disable the proxy, use
BASH
$ git config --global --unset http.proxy
$ git config --global --unset https.proxy
Git Help and Manual
Always remember that if you forget the subcommands or options of a
git
command, you can access the relevant list of options
typing git <command> -h
or access the corresponding
Git manual by typing git <command> --help
, e.g.:
BASH
$ git config -h
$ git config --help
While viewing the manual, remember the :
is a prompt
waiting for commands and you can press Q to exit the
manual.
More generally, you can get the list of available git
commands and further resources of the Git manual typing:
BASH
$ git help
Content from Creating a Repository
Last updated on 2023-11-14 | Edit this page
Estimated time 10 minutes
Overview
Questions
- Where does Git store information?
Objectives
- Create a local Git repository.
- Describe the purpose of the
.git
directory.
Once Git is configured, we can start using it.
We will continue with the story of Wolfman and Dracula who are investigating if it is possible to send a planetary lander to Mars.
Werewolf vs dracula by b-maze / Deviant Art. Mars by European Space Agency / CC-BY-SA 3.0 IGO. Pluto / Courtesy NASA/JPL-Caltech. Mummy © Gilad Fried / The Noun Project / CC BY 3.0. Moon © Luc Viatour / https://lucnix.be / CC BY-SA 3.0.
First, let’s create a new directory in the Desktop
folder for our work and then change the current working directory to the
newly created one:
BASH
$ cd ~/Desktop
$ mkdir planets
$ cd planets
Then we tell Git to make planets
a repository -- a place where Git can
store versions of our files:
BASH
$ git init
It is important to note that git init
will create a
repository that can include subdirectories and their files—there is no
need to create separate repositories nested within the
planets
repository, whether subdirectories are present from
the beginning or added later. Also, note that the creation of the
planets
directory and its initialization as a repository
are completely separate processes.
If we use ls
to show the directory’s contents, it
appears that nothing has changed:
BASH
$ ls
But if we add the -a
flag to show everything, we can see
that Git has created a hidden directory within planets
called .git
:
BASH
$ ls -a
OUTPUT
. .. .git
Git uses this special subdirectory to store all the information about
the project, including the tracked files and sub-directories located
within the project’s directory. If we ever delete the .git
subdirectory, we will lose the project’s history.
Next, we will change the default branch to be called
main
. This might be the default branch depending on your
settings and version of git. See the setup episode for
more information on this change.
BASH
$ git checkout -b main
OUTPUT
Switched to a new branch 'main'
We can check that everything is set up correctly by asking Git to tell us the status of our project:
BASH
$ git status
OUTPUT
On branch main
No commits yet
nothing to commit (create/copy files and use "git add" to track)
If you are using a different version of git
, the exact
wording of the output might be slightly different.
Places to Create Git Repositories
Along with tracking information about planets (the project we have
already created), Dracula would also like to track information about
moons. Despite Wolfman’s concerns, Dracula creates a moons
project inside his planets
project with the following
sequence of commands:
BASH
$ cd ~/Desktop # return to Desktop directory
$ cd planets # go into planets directory, which is already a Git repository
$ ls -a # ensure the .git subdirectory is still present in the planets directory
$ mkdir moons # make a subdirectory planets/moons
$ cd moons # go into moons subdirectory
$ git init # make the moons subdirectory a Git repository
$ ls -a # ensure the .git subdirectory is present indicating we have created a new Git repository
Is the git init
command, run inside the
moons
subdirectory, required for tracking files stored in
the moons
subdirectory?
No. Dracula does not need to make the moons
subdirectory
a Git repository because the planets
repository can track
any files, sub-directories, and subdirectory files under the
planets
directory. Thus, in order to track all information
about moons, Dracula only needed to add the moons
subdirectory to the planets
directory.
Additionally, Git repositories can interfere with each other if they
are “nested”: the outer repository will try to version-control the inner
repository. Therefore, it’s best to create each new Git repository in a
separate directory. To be sure that there is no conflicting repository
in the directory, check the output of git status
. If it
looks like the following, you are good to go to create a new repository
as shown above:
BASH
$ git status
OUTPUT
fatal: Not a git repository (or any of the parent directories): .git
Background
Removing files from a Git repository needs to be done with caution. But we have not learned yet how to tell Git to track a particular file; we will learn this in the next episode. Files that are not tracked by Git can easily be removed like any other “ordinary” files with
BASH
$ rm filename
Similarly a directory can be removed using rm -r dirname
or rm -rf dirname
. If the files or folder being removed in
this fashion are tracked by Git, then their removal becomes another
change that we will need to track, as we will see in the next
episode.
Solution
Git keeps all of its files in the .git
directory. To
recover from this little mistake, Dracula can just remove the
.git
folder in the moons subdirectory by running the
following command from inside the planets
directory:
BASH
$ rm -rf moons/.git
But be careful! Running this command in the wrong directory will
remove the entire Git history of a project you might want to keep.
Therefore, always check your current directory using the command
pwd
.
Content from Tracking Changes
Last updated on 2023-11-14 | Edit this page
Estimated time 20 minutes
Overview
Questions
- How do I record changes in Git?
- How do I check the status of my version control repository?
- How do I record notes about what changes I made and why?
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 planets
directory.
BASH
$ cd ~/Desktop/planets
Let’s create a file called mars.txt
that contains some
notes about the Red Planet’s suitability as a base. 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.
BASH
$ nano mars.txt
Type the text below into the mars.txt
file:
OUTPUT
Cold and dry, but everything is my favorite color
Let’s first verify that the file was properly created by running the
list command (ls
):
BASH
$ ls
OUTPUT
mars.txt
mars.txt
contains a single line, which we can see by
running:
BASH
$ cat mars.txt
OUTPUT
Cold and dry, but everything is my favorite color
If we check the status of our project again, Git tells us that it’s noticed the new file:
BASH
$ git status
OUTPUT
On branch main
No commits yet
Untracked files:
(use "git add <file>..." to include in what will be committed)
mars.txt
nothing added to commit but untracked files present (use "git add" to track)
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
:
BASH
$ git add mars.txt
and then check that the right thing happened:
BASH
$ git status
OUTPUT
On branch main
No commits yet
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file: mars.txt
Git now knows that it’s supposed to keep track of
mars.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:
BASH
$ git commit -m "Start notes on Mars as a base"
OUTPUT
[main (root-commit) f22b25e] Start notes on Mars as a base
1 file changed, 1 insertion(+)
create mode 100644 mars.txt
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:
BASH
$ git status
OUTPUT
On branch main
nothing to commit, working tree clean
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
:
BASH
$ git log
OUTPUT
commit f22b25e3233b4645dabd0d81e651fe074bd8e73b
Author: Vlad Dracula <vlad@tran.sylvan.ia>
Date: Thu Aug 22 09:51:46 2013 -0400
Start notes on Mars as a base
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 mars.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
.)
BASH
$ nano mars.txt
$ cat mars.txt
OUTPUT
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
When we run git status
now, it tells us that a file it
already knows about has been modified:
BASH
$ git status
OUTPUT
On branch main
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
modified: mars.txt
no changes added to commit (use "git add" and/or "git commit -a")
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:
BASH
$ git diff
OUTPUT
diff --git a/mars.txt b/mars.txt
index df0654a..315bf3a 100644
--- a/mars.txt
+++ b/mars.txt
@@ -1 +1,2 @@
Cold and dry, but everything is my favorite color
+The two moons may be a problem for Wolfman
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
diff
command comparing the old and new versions of the file. - The second line tells exactly which versions of the file Git is
comparing;
df0654a
and315bf3a
are 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:
BASH
$ git commit -m "Add concerns about effects of Mars' moons on Wolfman"
OUTPUT
On branch main
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
modified: mars.txt
no changes added to commit (use "git add" and/or "git commit -a")
Whoops: Git won’t commit because we didn’t use git add
first. Let’s fix that:
BASH
$ git add mars.txt
$ git commit -m "Add concerns about effects of Mars' moons on Wolfman"
OUTPUT
[main 34961b1] Add concerns about effects of Mars' moons on Wolfman
1 file changed, 1 insertion(+)
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:
BASH
$ nano mars.txt
$ cat mars.txt
OUTPUT
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
BASH
$ git diff
OUTPUT
diff --git a/mars.txt b/mars.txt
index 315bf3a..b36abfd 100644
--- a/mars.txt
+++ b/mars.txt
@@ -1,2 +1,3 @@
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
+But the Mummy will appreciate the lack of humidity
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:
BASH
$ git add mars.txt
$ git diff
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:
BASH
$ git diff --staged
OUTPUT
diff --git a/mars.txt b/mars.txt
index 315bf3a..b36abfd 100644
--- a/mars.txt
+++ b/mars.txt
@@ -1,2 +1,3 @@
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
+But the Mummy will appreciate the lack of humidity
it shows us the difference between the last committed change and what’s in the staging area. Let’s save our changes:
BASH
$ git commit -m "Discuss concerns about Mars' climate for Mummy"
OUTPUT
[main 005937f] Discuss concerns about Mars' climate for Mummy
1 file changed, 1 insertion(+)
check our status:
BASH
$ git status
OUTPUT
On branch main
nothing to commit, working tree clean
and look at the history of what we’ve done so far:
BASH
$ git log
OUTPUT
commit 005937fbe2a98fb83f0ade869025dc2636b4dad5 (HEAD -> main)
Author: Vlad Dracula <vlad@tran.sylvan.ia>
Date: Thu Aug 22 10:14:07 2013 -0400
Discuss concerns about Mars' climate for Mummy
commit 34961b159c27df3b475cfe4415d94a6d1fcd064d
Author: Vlad Dracula <vlad@tran.sylvan.ia>
Date: Thu Aug 22 10:07:21 2013 -0400
Add concerns about effects of Mars' moons on Wolfman
commit f22b25e3233b4645dabd0d81e651fe074bd8e73b
Author: Vlad Dracula <vlad@tran.sylvan.ia>
Date: Thu Aug 22 09:51:46 2013 -0400
Start notes on Mars as a base
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_word
in 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:
BASH
$ git log -1
OUTPUT
commit 005937fbe2a98fb83f0ade869025dc2636b4dad5 (HEAD -> main)
Author: Vlad Dracula <vlad@tran.sylvan.ia>
Date: Thu Aug 22 10:14:07 2013 -0400
Discuss concerns about Mars' climate for Mummy
You can also reduce the quantity of information using the
--oneline
option:
BASH
$ git log --oneline
OUTPUT
005937f (HEAD -> main) Discuss concerns about Mars' climate for Mummy
34961b1 Add concerns about effects of Mars' moons on Wolfman
f22b25e Start notes on Mars as a base
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:
BASH
$ git log --oneline --graph
OUTPUT
* 005937f (HEAD -> main) Discuss concerns about Mars' climate for Mummy
* 34961b1 Add concerns about effects of Mars' moons on Wolfman
* f22b25e Start notes on Mars as a base
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:
BASH
$ mkdir spaceships
$ git status
$ git add spaceships
$ git status
Note, our newly created empty directory spaceships
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:
BASH
git add <directory-with-files>
Try it for yourself:
BASH
$ touch spaceships/apollo-11 spaceships/sputnik-1
$ git status
$ git add spaceships
$ git status
Before moving on, we will commit these changes.
BASH
$ git commit -m "Add some initial thoughts on spaceships"
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
):
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"
- 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 some text to
mars.txt
noting your decision to consider Venus as a base - Create a new file
venus.txt
with your initial thoughts about Venus as a base for you and your friends - Add changes from both files to the staging area, and commit those changes.
The output below from cat mars.txt
reflects only content
added during this exercise. Your output may vary.
First we make our changes to the mars.txt
and
venus.txt
files:
BASH
$ nano mars.txt
$ cat mars.txt
OUTPUT
Maybe I should start with a base on Venus.
BASH
$ nano venus.txt
$ cat venus.txt
OUTPUT
Venus is a nice planet and I definitely should consider it as a base.
Now you can add both files to the staging area. We can do that in one line:
BASH
$ git add mars.txt venus.txt
Or with multiple commands:
BASH
$ git add mars.txt
$ git add venus.txt
Now the files are ready to commit. You can check that using
git status
. If you are ready to commit use:
BASH
$ git commit -m "Write plans to start a base on Venus"
OUTPUT
[main cc127c2]
Write plans to start a base on Venus
2 files changed, 2 insertions(+)
create mode 100644 venus.txt
If needed, move out of the planets
folder:
BASH
$ cd ..
Create a new folder called bio
and ‘move’ into it:
BASH
$ mkdir bio
$ cd bio
Initialise git:
BASH
$ git init
Create your biography file me.txt
using
nano
or another text editor. Once in place, add and commit
it to the repository:
BASH
$ git add me.txt
$ git commit -m "Add biography file"
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
:
BASH
$ git diff me.txt
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.
Content from Exploring History
Last updated on 2023-06-13 | Edit this page
Estimated time 25 minutes
Overview
Questions
- How can I identify old versions of files?
- How do I review my changes?
- How can I recover old versions of files?
Objectives
- Explain what the HEAD of a repository is and how to use it.
- Identify and use Git commit numbers.
- Compare various versions of tracked files.
- Restore old versions of files.
As we saw in the previous episode, we can refer to commits by their
identifiers. You can refer to the most recent commit of the
working directory by using the identifier HEAD
.
We’ve been adding one line at a time to mars.txt
, so
it’s easy to track our progress by looking, so let’s do that using our
HEAD
s. Before we start, let’s make a change to
mars.txt
, adding yet another line.
BASH
$ nano mars.txt
$ cat mars.txt
OUTPUT
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
An ill-considered change
Now, let’s see what we get.
BASH
$ git diff HEAD mars.txt
OUTPUT
diff --git a/mars.txt b/mars.txt
index b36abfd..0848c8d 100644
--- a/mars.txt
+++ b/mars.txt
@@ -1,3 +1,4 @@
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
+An ill-considered change.
which is the same as what you would get if you leave out
HEAD
(try it). The real goodness in all this is when you
can refer to previous commits. We do that by adding ~1
(where “~” is “tilde”, pronounced [til-duh])
to refer to the commit one before HEAD
.
BASH
$ git diff HEAD~1 mars.txt
If we want to see the differences between older commits we can use
git diff
again, but with the notation HEAD~1
,
HEAD~2
, and so on, to refer to them:
BASH
$ git diff HEAD~3 mars.txt
OUTPUT
diff --git a/mars.txt b/mars.txt
index df0654a..b36abfd 100644
--- a/mars.txt
+++ b/mars.txt
@@ -1 +1,4 @@
Cold and dry, but everything is my favorite color
+The two moons may be a problem for Wolfman
+But the Mummy will appreciate the lack of humidity
+An ill-considered change
We could also use git show
which shows us what changes
we made at an older commit as well as the commit message, rather than
the differences between a commit and our working directory that
we see by using git diff
.
BASH
$ git show HEAD~3 mars.txt
OUTPUT
commit f22b25e3233b4645dabd0d81e651fe074bd8e73b
Author: Vlad Dracula <vlad@tran.sylvan.ia>
Date: Thu Aug 22 09:51:46 2013 -0400
Start notes on Mars as a base
diff --git a/mars.txt b/mars.txt
new file mode 100644
index 0000000..df0654a
--- /dev/null
+++ b/mars.txt
@@ -0,0 +1 @@
+Cold and dry, but everything is my favorite color
In this way, we can build up a chain of commits. The most recent end
of the chain is referred to as HEAD
; we can refer to
previous commits using the ~
notation, so
HEAD~1
means “the previous commit”, while
HEAD~123
goes back 123 commits from where we are now.
We can also refer to commits using those long strings of digits and
letters that git log
displays. These are unique IDs for the
changes, and “unique” really does mean unique: every change to any set
of files on any computer has a unique 40-character identifier. Our first
commit was given the ID
f22b25e3233b4645dabd0d81e651fe074bd8e73b
, so let’s try
this:
BASH
$ git diff f22b25e3233b4645dabd0d81e651fe074bd8e73b mars.txt
OUTPUT
diff --git a/mars.txt b/mars.txt
index df0654a..93a3e13 100644
--- a/mars.txt
+++ b/mars.txt
@@ -1 +1,4 @@
Cold and dry, but everything is my favorite color
+The two moons may be a problem for Wolfman
+But the Mummy will appreciate the lack of humidity
+An ill-considered change
That’s the right answer, but typing out random 40-character strings is annoying, so Git lets us use just the first few characters (typically seven for normal size projects):
BASH
$ git diff f22b25e mars.txt
OUTPUT
diff --git a/mars.txt b/mars.txt
index df0654a..93a3e13 100644
--- a/mars.txt
+++ b/mars.txt
@@ -1 +1,4 @@
Cold and dry, but everything is my favorite color
+The two moons may be a problem for Wolfman
+But the Mummy will appreciate the lack of humidity
+An ill-considered change
All right! So we can save changes to files and see what we’ve
changed. Now, how can we restore older versions of things? Let’s suppose
we change our mind about the last update to mars.txt
(the
“ill-considered change”).
git status
now tells us that the file has been changed,
but those changes haven’t been staged:
BASH
$ git status
OUTPUT
On branch main
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
modified: mars.txt
no changes added to commit (use "git add" and/or "git commit -a")
We can put things back the way they were by using
git checkout
:
BASH
$ git checkout HEAD mars.txt
$ cat mars.txt
OUTPUT
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
As you might guess from its name, git checkout
checks
out (i.e., restores) an old version of a file. In this case, we’re
telling Git that we want to recover the version of the file recorded in
HEAD
, which is the last saved commit. If we want to go back
even further, we can use a commit identifier instead:
BASH
$ git checkout f22b25e mars.txt
BASH
$ cat mars.txt
OUTPUT
Cold and dry, but everything is my favorite color
BASH
$ git status
OUTPUT
On branch main
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
modified: mars.txt
Notice that the changes are currently in the staging area. Again, we
can put things back the way they were by using
git checkout
:
BASH
$ git checkout HEAD mars.txt
Don’t Lose Your HEAD
Above we used
BASH
$ git checkout f22b25e mars.txt
to revert mars.txt
to its state after the commit
f22b25e
. But be careful! The command checkout
has other important functionalities and Git will misunderstand your
intentions if you are not accurate with the typing. For example, if you
forget mars.txt
in the previous command.
BASH
$ git checkout f22b25e
ERROR
Note: checking out 'f22b25e'.
You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.
If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:
git checkout -b <new-branch-name>
HEAD is now at f22b25e Start notes on Mars as a base
The “detached HEAD” is like “look, but don’t touch” here, so you
shouldn’t make any changes in this state. After investigating your
repo’s past state, reattach your HEAD
with
git checkout main
.
It’s important to remember that we must use the commit number that
identifies the state of the repository before the change we’re
trying to undo. A common mistake is to use the number of the commit in
which we made the change we’re trying to discard. In the example below,
we want to retrieve the state from before the most recent commit
(HEAD~1
), which is commit f22b25e
:
So, to put it all together, here’s how Git works in cartoon form:
Simplifying the Common Case
If you read the output of git status
carefully, you’ll
see that it includes this hint:
OUTPUT
(use "git checkout -- <file>..." to discard changes in working directory)
As it says, git checkout
without a version identifier
restores files to the state saved in HEAD
. The double dash
--
is needed to separate the names of the files being
recovered from the command itself: without it, Git would try to use the
name of the file as the commit identifier.
The fact that files can be reverted one by one tends to change the way people organize their work. If everything is in one large document, it’s hard (but not impossible) to undo changes to the introduction without also undoing changes made later to the conclusion. If the introduction and conclusion are stored in separate files, on the other hand, moving backward and forward in time becomes much easier.
Recovering Older Versions of a File
Jennifer has made changes to the Python script that she has been working on for weeks, and the modifications she made this morning “broke” the script and it no longer runs. She has spent ~ 1hr trying to fix it, with no luck…
Luckily, she has been keeping track of her project’s versions using
Git! Which commands below will let her recover the last committed
version of her Python script called data_cruncher.py
?
$ git checkout HEAD
$ git checkout HEAD data_cruncher.py
$ git checkout HEAD~1 data_cruncher.py
$ git checkout <unique ID of last commit> data_cruncher.py
Both 2 and 4
The answer is (5)-Both 2 and 4.
The checkout
command restores files from the repository,
overwriting the files in your working directory. Answers 2 and 4 both
restore the latest version in the repository of the
file data_cruncher.py
. Answer 2 uses HEAD
to
indicate the latest, whereas answer 4 uses the unique ID of the
last commit, which is what HEAD
means.
Answer 3 gets the version of data_cruncher.py
from the
commit before HEAD
, which is NOT what we
wanted.
Answer 1 can be dangerous! Without a filename,
git checkout
will restore all files in the
current directory (and all directories below it) to their state at the
commit specified. This command will restore
data_cruncher.py
to the latest commit version, but it will
also restore any other files that are changed to that version,
erasing any changes you may have made to those files! As discussed
above, you are left in a detached HEAD
state, and
you don’t want to be there.
Reverting a Commit
Jennifer is collaborating with colleagues on her Python script. She
realizes her last commit to the project’s repository contained an error,
and wants to undo it. Jennifer wants to undo correctly so everyone in
the project’s repository gets the correct change. The command
git revert [erroneous commit ID]
will create a new commit
that reverses the erroneous commit.
The command git revert
is different from
git checkout [commit ID]
because git checkout
returns the files not yet committed within the local repository to a
previous state, whereas git revert
reverses changes
committed to the local and project repositories.
Below are the right steps and explanations for Jennifer to use
git revert
, what is the missing command?
________ # Look at the git history of the project to find the commit ID
Copy the ID (the first few characters of the ID, e.g. 0b1d055).
git revert [commit ID]
Type in the new commit message.
Save and close
The command git log
lists project history with commit
IDs.
The command git show HEAD
shows changes made at the
latest commit, and lists the commit ID; however, Jennifer should
double-check it is the correct commit, and no one else has committed
changes to the repository.
Understanding Workflow and History
What is the output of the last command in
BASH
$ cd planets
$ echo "Venus is beautiful and full of love" > venus.txt
$ git add venus.txt
$ echo "Venus is too hot to be suitable as a base" >> venus.txt
$ git commit -m "Comment on Venus as an unsuitable base"
$ git checkout HEAD venus.txt
$ cat venus.txt #this will print the contents of venus.txt to the screen
OUTPUT
Venus is too hot to be suitable as a base
OUTPUT
Venus is beautiful and full of love
OUTPUT
Venus is beautiful and full of love Venus is too hot to be suitable as a base
OUTPUT
Error because you have changed venus.txt without committing the changes
The answer is 2.
The command git add venus.txt
places the current version
of venus.txt
into the staging area. The changes to the file
from the second echo
command are only applied to the
working copy, not the version in the staging area.
So, when
git commit -m "Comment on Venus as an unsuitable base"
is
executed, the version of venus.txt
committed to the
repository is the one from the staging area and has only one line.
At this time, the working copy still has the second line (and
git status
will show that the file is modified). However,
git checkout HEAD venus.txt
replaces the working copy with
the most recently committed version of venus.txt
.
So, cat venus.txt
will output
OUTPUT
Venus is beautiful and full of love.
Checking Understanding of
git diff
Consider this command: git diff HEAD~9 mars.txt
. What do
you predict this command will do if you execute it? What happens when
you do execute it? Why?
Try another command, git diff [ID] mars.txt
, where [ID]
is replaced with the unique identifier for your most recent commit. What
do you think will happen, and what does happen?
Getting Rid of Staged Changes
git checkout
can be used to restore a previous commit
when unstaged changes have been made, but will it also work for changes
that have been staged but not committed? Make a change to
mars.txt
, add that change using git add
, then
use git checkout
to see if you can remove your change.
After adding a change, git checkout
can not be used
directly. Let’s look at the output of git status
:
OUTPUT
On branch main
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
modified: mars.txt
Note that if you don’t have the same output you may either have forgotten to change the file, or you have added it and committed it.
Using the command git checkout -- mars.txt
now does not
give an error, but it does not restore the file either. Git helpfully
tells us that we need to use git reset
first to unstage the
file:
BASH
$ git reset HEAD mars.txt
OUTPUT
Unstaged changes after reset:
M mars.txt
Now, git status
gives us:
BASH
$ git status
OUTPUT
On branch main
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
modified: mars.txt
no changes added to commit (use "git add" and/or "git commit -a")
This means we can now use git checkout
to restore the
file to the previous commit:
BASH
$ git checkout -- mars.txt
$ git status
OUTPUT
On branch main
nothing to commit, working tree clean
Explore and Summarize Histories
Exploring history is an important part of Git, and often it is a challenge to find the right commit ID, especially if the commit is from several months ago.
Imagine the planets
project has more than 50 files. You
would like to find a commit that modifies some specific text in
mars.txt
. When you type git log
, a very long
list appeared. How can you narrow down the search?
Recall that the git diff
command allows us to explore
one specific file, e.g., git diff mars.txt
. We can apply a
similar idea here.
BASH
$ git log mars.txt
Unfortunately some of these commit messages are very ambiguous, e.g.,
update files
. How can you search through these files?
Both git diff
and git log
are very useful
and they summarize a different part of the history for you. Is it
possible to combine both? Let’s try the following:
BASH
$ git log --patch mars.txt
You should get a long list of output, and you should be able to see both commit messages and the difference between each commit.
Question: What does the following command do?
BASH
$ git log --patch HEAD~9 *.txt
Content from Ignoring Things
Last updated on 2023-11-14 | Edit this page
Estimated time 5 minutes
Overview
Questions
- How can I tell Git to ignore files I don’t want to track?
Objectives
- Configure Git to ignore specific files.
- Explain why ignoring files can be useful.
What if we have files that we do not want Git to track for us, like backup files created by our editor or intermediate files created during data analysis? Let’s create a few dummy files:
BASH
$ mkdir results
$ touch a.csv b.csv c.csv results/a.out results/b.out
and see what Git says:
BASH
$ git status
OUTPUT
On branch main
Untracked files:
(use "git add <file>..." to include in what will be committed)
a.csv
b.csv
c.csv
results/
nothing added to commit but untracked files present (use "git add" to track)
Putting these files under version control would be a waste of disk space. What’s worse, having them all listed could distract us from changes that actually matter, so let’s tell Git to ignore them.
We do this by creating a file in the root directory of our project
called .gitignore
:
BASH
$ nano .gitignore
$ cat .gitignore
OUTPUT
*.csv
results/
These patterns tell Git to ignore any file whose name ends in
.csv
and everything in the results
directory.
(If any of these files were already being tracked, Git would continue to
track them.)
Once we have created this file, the output of git status
is much cleaner:
BASH
$ git status
OUTPUT
On branch main
Untracked files:
(use "git add <file>..." to include in what will be committed)
.gitignore
nothing added to commit but untracked files present (use "git add" to track)
The only thing Git notices now is the newly-created
.gitignore
file. You might think we wouldn’t want to track
it, but everyone we’re sharing our repository with will probably want to
ignore the same things that we’re ignoring. Let’s add and commit
.gitignore
:
BASH
$ git add .gitignore
$ git commit -m "Ignore data files and the results folder"
$ git status
OUTPUT
On branch main
nothing to commit, working tree clean
As a bonus, using .gitignore
helps us avoid accidentally
adding files to the repository that we don’t want to track:
BASH
$ git add a.csv
OUTPUT
The following paths are ignored by one of your .gitignore files:
a.csv
Use -f if you really want to add them.
If we really want to override our ignore settings, we can use
git add -f
to force Git to add something. For example,
git add -f a.csv
. We can also always see the status of
ignored files if we want:
BASH
$ git status --ignored
OUTPUT
On branch main
Ignored files:
(use "git add -f <file>..." to include in what will be committed)
a.csv
b.csv
c.csv
results/
nothing to commit, working tree clean
If you only want to ignore the contents of
results/plots
, you can change your .gitignore
to ignore only the /plots/
subfolder by adding the
following line to your .gitignore:
OUTPUT
results/plots/
This line will ensure only the contents of results/plots
is ignored, and not the contents of results/data
.
As with most programming issues, there are a few alternative ways that one may ensure this ignore rule is followed. The “Ignoring Nested Files: Variation” exercise has a slightly different directory structure that presents an alternative solution. Further, the discussion page has more detail on ignore rules.
You would add the following two lines to your .gitignore:
OUTPUT
*.csv # ignore all data files
!final.csv # except final.csv
The exclamation point operator will include a previously excluded entry.
Note also that because you’ve previously committed .csv
files in this lesson they will not be ignored with this new rule. Only
future additions of .csv
files added to the root directory
will be ignored.
Ignoring Nested Files: Variation
Given a directory structure that looks similar to the earlier Nested Files exercise, but with a slightly different directory structure:
BASH
results/data
results/images
results/plots
results/analysis
How would you ignore all of the contents in the results folder, but
not results/data
?
Hint: think a bit about how you created an exception with the
!
operator before.
If you want to ignore the contents of results/
but not
those of results/data/
, you can change your
.gitignore
to ignore the contents of results folder, but
create an exception for the contents of the results/data
subfolder. Your .gitignore would look like this:
OUTPUT
results/* # ignore everything in results folder
!results/data/ # do not ignore results/data/ contents
Ignoring all data Files in a Directory
Assuming you have an empty .gitignore file, and given a directory structure that looks like:
BASH
results/data/position/gps/a.csv
results/data/position/gps/b.csv
results/data/position/gps/c.csv
results/data/position/gps/info.txt
results/plots
What’s the shortest .gitignore
rule you could write to
ignore all .csv
files in
result/data/position/gps
? Do not ignore the
info.txt
.
Appending results/data/position/gps/*.csv
will match
every file in results/data/position/gps
that ends with
.csv
. The file
results/data/position/gps/info.txt
will not be ignored.
Ignoring all data Files in the repository
Let us assume you have many .csv
files in different
subdirectories of your repository. For example, you might have:
BASH
results/a.csv
data/experiment_1/b.csv
data/experiment_2/c.csv
data/experiment_2/variation_1/d.csv
How do you ignore all the .csv
files, without explicitly
listing the names of the corresponding folders?
In the .gitignore
file, write:
OUTPUT
**/*.csv
This will ignore all the .csv
files, regardless of their
position in the directory tree. You can still include some specific
exception with the exclamation point operator.
The !
modifier will negate an entry from a previously
defined ignore pattern. Because the !*.csv
entry negates
all of the previous .csv
files in the
.gitignore
, none of them will be ignored, and all
.csv
files will be tracked.
Log Files
You wrote a script that creates many intermediate log-files of the
form log_01
, log_02
, log_03
, etc.
You want to keep them but you do not want to track them through
git
.
Write one
.gitignore
entry that excludes files of the formlog_01
,log_02
, etc.Test your “ignore pattern” by creating some dummy files of the form
log_01
, etc.You find that the file
log_01
is very important after all, add it to the tracked files without changing the.gitignore
again.Discuss with your neighbor what other types of files could reside in your directory that you do not want to track and thus would exclude via
.gitignore
.
- append either
log_*
orlog*
as a new entry in your .gitignore - track
log_01
usinggit add -f log_01
Content from Remotes in GitHub
Last updated on 2023-11-14 | Edit this page
Estimated time 45 minutes
Overview
Questions
- How do I share my changes with others on the web?
Objectives
- Explain what remote repositories are and why they are useful.
- Push to or pull from a remote repository.
Version control really comes into its own when we begin to collaborate with other people. We already have most of the machinery we need to do this; the only thing missing is to copy changes from one repository to another.
Systems like Git allow us to move work between any two repositories. In practice, though, it’s easiest to use one copy as a central hub, and to keep it on the web rather than on someone’s laptop. Most programmers use hosting services like GitHub, Bitbucket or GitLab to hold those main copies; we’ll explore the pros and cons of this in a later episode.
Let’s start by sharing the changes we’ve made to our current project with the world. To this end we are going to create a remote repository that will be linked to our local repository.
1. Create a remote repository
Log in to GitHub, then click on the
icon in the top right corner to create a new repository called
planets
:
Name your repository “planets” and then click “Create Repository”.
Note: Since this repository will be connected to a local repository, it needs to be empty. Leave “Initialize this repository with a README” unchecked, and keep “None” as options for both “Add .gitignore” and “Add a license.” See the “GitHub License and README files” exercise below for a full explanation of why the repository needs to be empty.
As soon as the repository is created, GitHub displays a page with a URL and some information on how to configure your local repository:
This effectively does the following on GitHub’s servers:
BASH
$ mkdir planets
$ cd planets
$ git init
If you remember back to the earlier episode where we added and committed our
earlier work on mars.txt
, we had a diagram of the local
repository which looked like this:
Now that we have two repositories, we need a diagram like this:
Note that our local repository still contains our earlier work on
mars.txt
, but the remote repository on GitHub appears empty
as it doesn’t contain any files yet.
2. Connect local to remote repository
Now we connect the two repositories. We do this by making the GitHub repository a remote for the local repository. The home page of the repository on GitHub includes the URL string we need to identify it:
If you are using SSH (see below), click on the ‘SSH’ link to change the protocol from HTTPS to SSH. If you are using the GitHub CLI and an access token keep HTTPS, or click on ’HTTPS’to return to the HTTPS protocol.
HTTPS vs. SSH
To commit changes to a repository you need a secure protocol. We
describe two alternatives provided by GitHub: HTTPS using the OAuth
protocol and tokens and SSH. If you have the GitHub CLI (comman line interpreter),
gh
, it is very easy to use HTTPS. The GitHub CLI may be
available on your host, check with gh --version
, or easily installed
on Mac, Windows or Linux (with admin privileges). Then you can create an
access
token via gh auth login
and authenticate via HTTPS.
Otherwise, if not using GitHub CLI, use SSH as described below. It
requires some additional configuration, but it is a standard security
protocol widely used by many applications. The steps below describe SSH
at a minimum level for GitHub.
Copy that URL from the browser, go into the local
planets
repository, and run one of the following commands.
If using GitHub CLI, access tokens, and HTTPS:
BASH
$ git remote add origin https://github.com/vlad/planets.git
If using SSH:
BASH
$ git remote add origin git@github.com:vlad/planets.git
Make sure to use the URL for your repository rather than Vlad’s: the
only difference should be your username instead of
vlad
.
origin
is a local name used to refer to the remote
repository. It could be called anything, but origin
is a
convention that is often used by default in git and GitHub, so it’s
helpful to stick with this unless there’s a reason not to.
We can check that the command has worked by running
git remote -v
:
BASH
$ git remote -v
OUTPUT
# If using HTTPS (GitHub CLI and tokens) you should have:
origin https://github.com/vlad/planets.git (fetch)
origin https://github.com/vlad/planets.git (push)
# If using SSH you should have
origin git@github.com:vlad/planets.git (fetch)
origin git@github.com:vlad/planets.git (push)
We’ll discuss remotes in more detail in the next episode, while talking about how they might be used for collaboration.
3. SSH Background and Setup
Before Dracula can connect to a remote repository, he needs to set up a way for his computer to authenticate with GitHub so it knows it’s him trying to connect to his remote repository.
Skip this section if you are using HTTPS and tokens via
gh auth login
as mentioned above in HTTPS vs. SSH.
Here we are going to set up the method that is commonly used by many different services to authenticate access on the command line. This method is called Secure Shell Protocol (SSH). SSH is a cryptographic network protocol that allows secure communication between computers using an otherwise insecure network.
SSH uses what is called a key pair. This is two keys that work together to validate access. One key is publicly known and called the public key, and the other key called the private key is kept private. Very descriptive names.
You can think of the public key as a padlock, and only you have the key (the private key) to open it. You use the public key where you want a secure method of communication, such as your GitHub account. You give this padlock, or public key, to GitHub and say “lock the communications to my account with this so that only computers that have my private key can unlock communications and send git commands as my GitHub account.”
What we will do now is the minimum required to set up the SSH keys and add the public key to a GitHub account.
The first thing we are going to do is check if this has already been done on the computer you’re on. Because generally speaking, this setup only needs to happen once and then you can forget about it.
We will run the list command to check what key pairs already exist on your computer.
BASH
ls -al ~/.ssh
Your output is going to look a little different depending on whether or not SSH has ever been set up on the computer you are using.
Dracula has not set up SSH on his computer, so his output is
OUTPUT
ls: cannot access '/c/Users/Vlad Dracula/.ssh': No such file or directory
If SSH has been set up on the computer you’re using, the public and
private key pairs will be listed. The file names are either
id_ed25519
/id_ed25519.pub
or
id_rsa
/id_rsa.pub
depending on how the key
pairs were set up.
Since they don’t exist on Dracula’s computer, he uses this command to
create them.
3.1 Create an SSH key pair
To create an SSH key pair Vlad uses this command, where the
-t
option specifies which type of algorithm to use and
-C
attaches a comment to the key (here, Vlad’s email):
BASH
$ ssh-keygen -t ed25519 -C "vlad@tran.sylvan.ia"
If you are using a legacy system that doesn’t support the Ed25519
algorithm, use:
$ ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
OUTPUT
Generating public/private ed25519 key pair.
Enter file in which to save the key (/c/Users/Vlad Dracula/.ssh/id_ed25519):
We want to use the default file, so just press Enter.
OUTPUT
Created directory '/c/Users/Vlad Dracula/.ssh'.
Enter passphrase (empty for no passphrase):
Now, it is prompting Dracula for a passphrase. Since he is using his lab’s laptop that other people sometimes have access to, he wants to create a passphrase. Be sure to use something memorable or save your passphrase somewhere, as there is no “reset my password” option.
OUTPUT
Enter same passphrase again:
After entering the same passphrase a second time, we receive the confirmation
OUTPUT
Your identification has been saved in /c/Users/Vlad Dracula/.ssh/id_ed25519
Your public key has been saved in /c/Users/Vlad Dracula/.ssh/id_ed25519.pub
The key fingerprint is:
SHA256:SMSPIStNyA00KPxuYu94KpZgRAYjgt9g4BA4kFy3g1o vlad@tran.sylvan.ia
The key's randomart image is:
+--[ED25519 256]--+
|^B== o. |
|%*=.*.+ |
|+=.E =.+ |
| .=.+.o.. |
|.... . S |
|.+ o |
|+ = |
|.o.o |
|oo+. |
+----[SHA256]-----+
The “identification” is actually the private key. You should never share it. The public key is appropriately named. The “key fingerprint” is a shorter version of a public key.
Now that we have generated the SSH keys, we will find the SSH files when we check.
BASH
ls -al ~/.ssh
OUTPUT
drwxr-xr-x 1 Vlad Dracula 197121 0 Jul 16 14:48 ./
drwxr-xr-x 1 Vlad Dracula 197121 0 Jul 16 14:48 ../
-rw-r--r-- 1 Vlad Dracula 197121 419 Jul 16 14:48 id_ed25519
-rw-r--r-- 1 Vlad Dracula 197121 106 Jul 16 14:48 id_ed25519.pub
3.2 Copy the public key to GitHub
Now we have a SSH key pair and we can run this command to check if GitHub can read our authentication.
BASH
ssh -T git@github.com
OUTPUT
The authenticity of host 'github.com (192.30.255.112)' can't be established.
RSA key fingerprint is SHA256:nThbg6kXUpJWGl7E1IGOCspRomTxdCARLviKw6E5SY8.
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])? y
Please type 'yes', 'no' or the fingerprint: yes
Warning: Permanently added 'github.com' (RSA) to the list of known hosts.
git@github.com: Permission denied (publickey).
Right, we forgot that we need to give GitHub our public key!
First, we need to copy the public key. Be sure to include the
.pub
at the end, otherwise you’re looking at the private
key.
BASH
cat ~/.ssh/id_ed25519.pub
OUTPUT
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDmRA3d51X0uu9wXek559gfn6UFNF69yZjChyBIU2qKI vlad@tran.sylvan.ia
Now, going to GitHub.com, click on your profile icon in the top right corner to get the drop-down menu. Click “Settings,” then on the settings page, click “SSH and GPG keys,” on the left side “Account settings” menu. Click the “New SSH key” button on the right side. Now, you can add the title (Dracula uses the title “Vlad’s Lab Laptop” so he can remember where the original key pair files are located), paste your SSH key into the field, and click the “Add SSH key” to complete the setup.
Now that we’ve set that up, let’s check our authentication again from the command line.
BASH
$ ssh -T git@github.com
OUTPUT
Hi Vlad! You've successfully authenticated, but GitHub does not provide shell access.
Good! This output confirms that the SSH key works as intended. We are now ready to push our work to the remote repository.
3.3 Using ssh-agent and adding your key
Whenever Git needs your key to authenticate to GitHub you will have
to type your passphrase. This process may become tedious and can be
avoided using a key manager like ssh-agent.
It holds your keys and certificates in memory, unencrypted, and ready
for use by ssh. To start a session run:
BASH
eval $(ssh-agent)
To add keys use:
BASH
ssh-add
This will find and add the defeult keys in ~/.ssh/
,
including ~/.ssh/id_ed25519
that we created above. You will
have to type the passphrase of each added key.
To end a session run:
BASH
kill $SSH_AGENT_PID
4. Push local changes to a remote
Now that authentication is setup, we can return to the remote. This command will push the changes from our local repository to the repository on GitHub:
BASH
$ git push origin main
Since Dracula set up a passphrase, it will prompt him for it. If you completed advanced settings for your authentication, it will not prompt for a passphrase.
OUTPUT
Enumerating objects: 16, done.
Counting objects: 100% (16/16), done.
Delta compression using up to 8 threads.
Compressing objects: 100% (11/11), done.
Writing objects: 100% (16/16), 1.45 KiB | 372.00 KiB/s, done.
Total 16 (delta 2), reused 0 (delta 0)
remote: Resolving deltas: 100% (2/2), done.
To https://github.com/vlad/planets.git
* [new branch] main -> main
Proxy
If the network you are connected to uses a proxy, there is a chance that your last command failed with “Could not resolve hostname” as the error message. To solve this issue, you need to tell Git about the proxy:
BASH
$ git config --global http.proxy http://user:password@proxy.url
$ git config --global https.proxy https://user:password@proxy.url
When you connect to another network that doesn’t use a proxy, you will need to tell Git to disable the proxy using:
BASH
$ git config --global --unset http.proxy
$ git config --global --unset https.proxy
Password Managers
If your operating system has a password manager configured,
git push
will try to use it when it needs your username and
password. For example, this is the default behavior for Git Bash on
Windows. If you want to type your username and password at the terminal
instead of using a password manager, type:
BASH
$ unset SSH_ASKPASS
in the terminal, before you run git push
. Despite the
name, Git
uses SSH_ASKPASS
for all credential entry, so you may
want to unset SSH_ASKPASS
whether you are using Git via SSH
or https.
You may also want to add unset SSH_ASKPASS
at the end of
your ~/.bashrc
to make Git default to using the terminal
for usernames and passwords.
Our local and remote repositories are now in this state:
The ‘-u’ Flag
You may see a -u
option used with git push
in some documentation. This option is synonymous with the
--set-upstream-to
option for the git branch
command, and is used to associate the current branch with a remote
branch so that the git pull
command can be used without any
arguments. To do this, simply use git push -u origin main
once the remote has been set up.
We can pull changes from the remote repository to the local one as well:
BASH
$ git pull origin main
OUTPUT
From https://github.com/vlad/planets
* branch main -> FETCH_HEAD
Already up-to-date.
Pulling has no effect in this case because the two repositories are already synchronized. If someone else had pushed some changes to the repository on GitHub, though, this command would download them to our local repository.
GitHub GUI
Browse to your planets
repository on GitHub. Underneath
the Code button, find and click on the text that says “XX commits”
(where “XX” is some number). Hover over, and click on, the three buttons
to the right of each commit. What information can you gather/explore
from these buttons? How would you get that same information in the
shell?
The left-most button (with the picture of a clipboard) copies the
full identifier of the commit to the clipboard. In the shell,
git log
will show you the full commit identifier for each
commit.
When you click on the middle button, you’ll see all of the changes
that were made in that particular commit. Green shaded lines indicate
additions and red ones removals. In the shell we can do the same thing
with git diff
. In particular,
git diff ID1..ID2
where ID1 and ID2 are commit identifiers
(e.g. git diff a3bf1e5..041e637
) will show the differences
between those two commits.
The right-most button lets you view all of the files in the
repository at the time of that commit. To do this in the shell, we’d
need to checkout the repository at that particular time. We can do this
with git checkout ID
where ID is the identifier of the
commit we want to look at. If we do this, we need to remember to put the
repository back to the right state afterwards!
Uploading files directly in GitHub browser
Github also allows you to skip the command line and upload files directly to your repository without having to leave the browser. There are two options. First you can click the “Upload files” button in the toolbar at the top of the file tree. Or, you can drag and drop files from your desktop onto the file tree. You can read more about this on this GitHub page.
GitHub Timestamp
Create a remote repository on GitHub. Push the contents of your local repository to the remote. Make changes to your local repository and push these changes. Go to the repo you just created on GitHub and check the timestamps of the files. How does GitHub record times, and why?
GitHub displays timestamps in a human readable relative format (i.e. “22 hours ago” or “three weeks ago”). However, if you hover over the timestamp, you can see the exact time at which the last change to the file occurred.
When we push changes, we’re interacting with a remote repository to update it with the changes we’ve made locally (often this corresponds to sharing the changes we’ve made with others). Commit only updates your local repository.
GitHub License and README files
In this episode we learned about creating a remote repository on GitHub, but when you initialized your GitHub repo, you didn’t add a README.md or a license file. If you had, what do you think would have happened when you tried to link your local and remote repositories?
In this case, we’d see a merge conflict due to unrelated histories. When GitHub creates a README.md file, it performs a commit in the remote repository. When you try to pull the remote repository to your local repository, Git detects that they have histories that do not share a common origin and refuses to merge.
BASH
$ git pull origin main
OUTPUT
warning: no common commits
remote: Enumerating objects: 3, done.
remote: Counting objects: 100% (3/3), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), done.
From https://github.com/vlad/planets
* branch main -> FETCH_HEAD
* [new branch] main -> origin/main
fatal: refusing to merge unrelated histories
You can force git to merge the two repositories with the option
--allow-unrelated-histories
. Be careful when you use this
option and carefully examine the contents of local and remote
repositories before merging.
BASH
$ git pull --allow-unrelated-histories origin main
OUTPUT
From https://github.com/vlad/planets
* branch main -> FETCH_HEAD
Merge made by the 'recursive' strategy.
README.md | 1 +
1 file changed, 1 insertion(+)
create mode 100644 README.md
Keypoints
- A local Git repository can be connected to one or more remote repositories.
- Use OAuth via GitHub CLI or the SSH protocol to connect to remote repositories.
-
git push
copies changes from a local repository to a remote repository. -
git pull
copies changes from a remote repository to a local repository.
Content from Collaborating
Last updated on 2023-11-14 | Edit this page
Estimated time 25 minutes
Overview
Questions
- How can I use version control to collaborate with other people?
Objectives
- Clone a remote repository.
- Collaborate by pushing to a common repository.
- Describe the basic collaborative workflow.
For the next step, get into pairs. One person will be the “Owner” and the other will be the “Collaborator”. The goal is that the Collaborator add changes into the Owner’s repository. We will switch roles at the end, so both persons will play Owner and Collaborator.
The Owner needs to give the Collaborator access. In your repository page on GitHub, click the “Settings” button on the right, select “Collaborators”, click “Add people”, and then enter your partner’s username.
To accept access to the Owner’s repo, the Collaborator needs to go to https://github.com/notifications or check for email notification. Once there she can accept access to the Owner’s repo.
Next, the Collaborator needs to download a copy of the Owner’s repository to her machine. This is called “cloning a repo”.
The Collaborator doesn’t want to overwrite her own version of
planets.git
, so needs to clone the Owner’s repository to a
different location than her own repository with the same name.
To clone the Owner’s repo into her Desktop
folder, the
Collaborator enters:
BASH
$ git clone git@github.com:vlad/planets.git ~/Desktop/vlad-planets
Replace ‘vlad’ with the Owner’s username.
If you choose to clone without the clone path
(~/Desktop/vlad-planets
) specified at the end, you will
clone inside your own planets folder! Make sure to navigate to the
Desktop
folder first.
The Collaborator can now make a change in her clone of the Owner’s repository, exactly the same way as we’ve been doing before:
BASH
$ cd ~/Desktop/vlad-planets
$ nano pluto.txt
$ cat pluto.txt
OUTPUT
It is so a planet!
BASH
$ git add pluto.txt
$ git commit -m "Add notes about Pluto"
OUTPUT
1 file changed, 1 insertion(+)
create mode 100644 pluto.txt
Then push the change to the Owner’s repository on GitHub:
BASH
$ git push origin main
OUTPUT
Enumerating objects: 4, done.
Counting objects: 4, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 306 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
To https://github.com/vlad/planets.git
9272da5..29aba7c main -> main
Note that we didn’t have to create a remote called
origin
: Git uses this name by default when we clone a
repository. (This is why origin
was a sensible choice
earlier when we were setting up remotes by hand.)
Take a look at the Owner’s repository on GitHub again, and you should be able to see the new commit made by the Collaborator. You may need to refresh your browser to see the new commit.
Some more about remotes
In this episode and the previous one, our local repository has had a
single “remote”, called origin
. A remote is a copy of the
repository that is hosted somewhere else, that we can push to and pull
from, and there’s no reason that you have to work with only one. For
example, on some large projects you might have your own copy in your own
GitHub account (you’d probably call this origin
) and also
the main “upstream” project repository (let’s call this
upstream
for the sake of examples). You would pull from
upstream
from time to time to get the latest updates that
other people have committed.
Remember that the name you give to a remote only exists locally. It’s
an alias that you choose - whether origin
, or
upstream
, or fred
- and not something
intrinstic to the remote repository.
The git remote
family of commands is used to set up and
alter the remotes associated with a repository. Here are some of the
most useful ones:
-
git remote -v
lists all the remotes that are configured (we already used this in the last episode) -
git remote add [name] [url]
is used to add a new remote -
git remote remove [name]
removes a remote. Note that it doesn’t affect the remote repository at all - it just removes the link to it from the local repo. -
git remote set-url [name] [newurl]
changes the URL that is associated with the remote. This is useful if it has moved, e.g. to a different GitHub account, or from GitHub to a different hosting service. Or, if we made a typo when adding it! -
git remote rename [oldname] [newname]
changes the local alias by which a remote is known - its name. For example, one could use this to changeupstream
tofred
.
To download the Collaborator’s changes from GitHub, the Owner now enters:
BASH
$ git pull origin main
OUTPUT
remote: Enumerating objects: 4, done.
remote: Counting objects: 100% (4/4), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 0), reused 3 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), done.
From https://github.com/vlad/planets
* branch main -> FETCH_HEAD
9272da5..29aba7c main -> origin/main
Updating 9272da5..29aba7c
Fast-forward
pluto.txt | 1 +
1 file changed, 1 insertion(+)
create mode 100644 pluto.txt
Now the three repositories (Owner’s local, Collaborator’s local, and Owner’s on GitHub) are back in sync.
A Basic Collaborative Workflow
In practice, it is good to be sure that you have an updated version
of the repository you are collaborating on, so you should
git pull
before making our changes. The basic collaborative
workflow would be:
- update your local repo with
git pull origin main
, - make your changes and stage them with
git add
, - commit your changes with
git commit -m
, and - upload the changes to GitHub with
git push origin main
It is better to make many commits with smaller changes rather than of one commit with massive changes: small commits are easier to read and review.
On the command line, the Collaborator can use
git fetch origin main
to get the remote changes into the
local repository, but without merging them. Then by running
git diff main origin/main
the Collaborator will see the
changes output in the terminal.
On GitHub, the Collaborator can go to the repository and click on “commits” to view the most recent commits pushed to the repository.
Content from Conflicts
Last updated on 2023-06-13 | Edit this page
Estimated time 15 minutes
Overview
Questions
- What do I do when my changes conflict with someone else’s?
Objectives
- Explain what conflicts are and when they can occur.
- Resolve conflicts resulting from a merge.
As soon as people can work in parallel, they’ll likely step on each other’s toes. This will even happen with a single person: if we are working on a piece of software on both our laptop and a server in the lab, we could make different changes to each copy. Version control helps us manage these conflicts by giving us tools to resolve overlapping changes.
To see how we can resolve conflicts, we must first create one. The
file mars.txt
currently looks like this in both partners’
copies of our planets
repository:
BASH
$ cat mars.txt
OUTPUT
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
Let’s add a line to the collaborator’s copy only:
BASH
$ nano mars.txt
$ cat mars.txt
OUTPUT
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
This line added to Wolfman's copy
and then push the change to GitHub:
BASH
$ git add mars.txt
$ git commit -m "Add a line in our home copy"
OUTPUT
[main 5ae9631] Add a line in our home copy
1 file changed, 1 insertion(+)
BASH
$ git push origin main
OUTPUT
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 8 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 331 bytes | 331.00 KiB/s, done.
Total 3 (delta 2), reused 0 (delta 0)
remote: Resolving deltas: 100% (2/2), completed with 2 local objects.
To https://github.com/vlad/planets.git
29aba7c..dabb4c8 main -> main
Now let’s have the owner make a different change to their copy without updating from GitHub:
BASH
$ nano mars.txt
$ cat mars.txt
OUTPUT
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
We added a different line in the other copy
We can commit the change locally:
BASH
$ git add mars.txt
$ git commit -m "Add a line in my copy"
OUTPUT
[main 07ebc69] Add a line in my copy
1 file changed, 1 insertion(+)
but Git won’t let us push it to GitHub:
BASH
$ git push origin main
OUTPUT
To https://github.com/vlad/planets.git
! [rejected] main -> main (fetch first)
error: failed to push some refs to 'https://github.com/vlad/planets.git'
hint: Updates were rejected because the remote contains work that you do
hint: not have locally. This is usually caused by another repository pushing
hint: to the same ref. You may want to first integrate the remote changes
hint: (e.g., 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.
Git rejects the push because it detects that the remote repository has new updates that have not been incorporated into the local branch. What we have to do is pull the changes from GitHub, merge them into the copy we’re currently working in, and then push that. Let’s start by pulling:
BASH
$ git pull origin main
OUTPUT
remote: Enumerating objects: 5, done.
remote: Counting objects: 100% (5/5), done.
remote: Compressing objects: 100% (1/1), done.
remote: Total 3 (delta 2), reused 3 (delta 2), pack-reused 0
Unpacking objects: 100% (3/3), done.
From https://github.com/vlad/planets
* branch main -> FETCH_HEAD
29aba7c..dabb4c8 main -> origin/main
Auto-merging mars.txt
CONFLICT (content): Merge conflict in mars.txt
Automatic merge failed; fix conflicts and then commit the result.
The git pull
command updates the local repository to
include those changes already included in the remote repository. After
the changes from remote branch have been fetched, Git detects that
changes made to the local copy overlap with those made to the remote
repository, and therefore refuses to merge the two versions to stop us
from trampling on our previous work. The conflict is marked in in the
affected file:
BASH
$ cat mars.txt
OUTPUT
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
<<<<<<< HEAD
We added a different line in the other copy
=======
This line added to Wolfman's copy
>>>>>>> dabb4c8c450e8475aee9b14b4383acc99f42af1d
Our change is preceded by
<<<<<<< HEAD
. Git has then inserted
=======
as a separator between the conflicting changes and
marked the end of the content downloaded from GitHub with
>>>>>>>
. (The string of letters and
digits after that marker identifies the commit we’ve just
downloaded.)
It is now up to us to edit this file to remove these markers and reconcile the changes. We can do anything we want: keep the change made in the local repository, keep the change made in the remote repository, write something new to replace both, or get rid of the change entirely. Let’s replace both so that the file looks like this:
BASH
$ cat mars.txt
OUTPUT
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
We removed the conflict on this line
To finish merging, we add mars.txt
to the changes being
made by the merge and then commit:
BASH
$ git add mars.txt
$ git status
OUTPUT
On branch main
All conflicts fixed but you are still merging.
(use "git commit" to conclude merge)
Changes to be committed:
modified: mars.txt
BASH
$ git commit -m "Merge changes from GitHub"
OUTPUT
[main 2abf2b1] Merge changes from GitHub
Now we can push our changes to GitHub:
BASH
$ git push origin main
OUTPUT
Enumerating objects: 10, done.
Counting objects: 100% (10/10), done.
Delta compression using up to 8 threads
Compressing objects: 100% (6/6), done.
Writing objects: 100% (6/6), 645 bytes | 645.00 KiB/s, done.
Total 6 (delta 4), reused 0 (delta 0)
remote: Resolving deltas: 100% (4/4), completed with 2 local objects.
To https://github.com/vlad/planets.git
dabb4c8..2abf2b1 main -> main
Git keeps track of what we’ve merged with what, so we don’t have to fix things by hand again when the collaborator who made the first change pulls again:
BASH
$ git pull origin main
OUTPUT
remote: Enumerating objects: 10, done.
remote: Counting objects: 100% (10/10), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 6 (delta 4), reused 6 (delta 4), pack-reused 0
Unpacking objects: 100% (6/6), done.
From https://github.com/vlad/planets
* branch main -> FETCH_HEAD
dabb4c8..2abf2b1 main -> origin/main
Updating dabb4c8..2abf2b1
Fast-forward
mars.txt | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
We get the merged file:
BASH
$ cat mars.txt
OUTPUT
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
We removed the conflict on this line
We don’t need to merge again because Git knows someone has already done that.
Git’s ability to resolve conflicts is very useful, but conflict resolution costs time and effort, and can introduce errors if conflicts are not resolved correctly. If you find yourself resolving a lot of conflicts in a project, consider these technical approaches to reducing them:
- Pull from upstream more frequently, especially before starting new work
- Use topic branches to segregate work, merging to main when complete
- Make smaller more atomic commits
- Push your work when it is done and encourage your team to do the same to reduce work in progress and, by extension, the chance of having conflicts
- Where logically appropriate, break large files into smaller ones so that it is less likely that two authors will alter the same file simultaneously
Conflicts can also be minimized with project management strategies:
- Clarify who is responsible for what areas with your collaborators
- Discuss what order tasks should be carried out in with your collaborators so that tasks expected to change the same lines won’t be worked on simultaneously
- If the conflicts are stylistic churn (e.g. tabs vs. spaces),
establish a project convention that is governing and use code style
tools (e.g.
htmltidy
,perltidy
,rubocop
, etc.) to enforce, if necessary
Let’s try it. Suppose Dracula takes a picture of Martian surface and
calls it mars.jpg
.
If you do not have an image file of Mars available, you can create a dummy binary file like this:
BASH
$ head -c 1024 /dev/urandom > mars.jpg
$ ls -lh mars.jpg
OUTPUT
-rw-r--r-- 1 vlad 57095 1.0K Mar 8 20:24 mars.jpg
ls
shows us that this created a 1-kilobyte file. It is
full of random bytes read from the special file,
/dev/urandom
.
Now, suppose Dracula adds mars.jpg
to his
repository:
BASH
$ git add mars.jpg
$ git commit -m "Add picture of Martian surface"
OUTPUT
[main 8e4115c] Add picture of Martian surface
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 mars.jpg
Suppose that Wolfman has added a similar picture in the meantime. His
is a picture of the Martian sky, but it is also called
mars.jpg
. When Dracula tries to push, he gets a familiar
message:
BASH
$ git push origin main
OUTPUT
To https://github.com/vlad/planets.git
! [rejected] main -> main (fetch first)
error: failed to push some refs to 'https://github.com/vlad/planets.git'
hint: Updates were rejected because the remote contains work that you do
hint: not have locally. This is usually caused by another repository pushing
hint: to the same ref. You may want to first integrate the remote changes
hint: (e.g., 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.
We’ve learned that we must pull first and resolve any conflicts:
BASH
$ git pull origin main
When there is a conflict on an image or other binary file, git prints a message like this:
OUTPUT
$ git pull origin main
remote: Counting objects: 3, done.
remote: Compressing objects: 100% (3/3), done.
remote: Total 3 (delta 0), reused 0 (delta 0)
Unpacking objects: 100% (3/3), done.
From https://github.com/vlad/planets.git
* branch main -> FETCH_HEAD
6a67967..439dc8c main -> origin/main
warning: Cannot merge binary files: mars.jpg (HEAD vs. 439dc8c08869c342438f6dc4a2b615b05b93c76e)
Auto-merging mars.jpg
CONFLICT (add/add): Merge conflict in mars.jpg
Automatic merge failed; fix conflicts and then commit the result.
The conflict message here is mostly the same as it was for
mars.txt
, but there is one key additional line:
OUTPUT
warning: Cannot merge binary files: mars.jpg (HEAD vs. 439dc8c08869c342438f6dc4a2b615b05b93c76e)
Git cannot automatically insert conflict markers into an image as it does for text files. So, instead of editing the image file, we must check out the version we want to keep. Then we can add and commit this version.
On the key line above, Git has conveniently given us commit
identifiers for the two versions of mars.jpg
. Our version
is HEAD
, and Wolfman’s version is 439dc8c0...
.
If we want to use our version, we can use git checkout
:
BASH
$ git checkout HEAD mars.jpg
$ git add mars.jpg
$ git commit -m "Use image of surface instead of sky"
OUTPUT
[main 21032c3] Use image of surface instead of sky
If instead we want to use Wolfman’s version, we can use
git checkout
with Wolfman’s commit identifier,
439dc8c0
:
BASH
$ git checkout 439dc8c0 mars.jpg
$ git add mars.jpg
$ git commit -m "Use image of sky instead of surface"
OUTPUT
[main da21b34] Use image of sky instead of surface
We can also keep both images. The catch is that we cannot keep them under the same name. But, we can check out each version in succession and rename it, then add the renamed versions. First, check out each image and rename it:
BASH
$ git checkout HEAD mars.jpg
$ git mv mars.jpg mars-surface.jpg
$ git checkout 439dc8c0 mars.jpg
$ mv mars.jpg mars-sky.jpg
Then, remove the old mars.jpg
and add the two new
files:
BASH
$ git rm mars.jpg
$ git add mars-surface.jpg
$ git add mars-sky.jpg
$ git commit -m "Use two images: surface and sky"
OUTPUT
[main 94ae08c] Use two images: surface and sky
2 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 mars-sky.jpg
rename mars.jpg => mars-surface.jpg (100%)
Now both images of Mars are checked into the repository, and
mars.jpg
no longer exists.
A Typical Work Session
You sit down at your computer to work on a shared project that is tracked in a remote Git repository. During your work session, you take the following actions, but not in this order:
-
Make changes by appending the number
100
to a text filenumbers.txt
- Update remote repository to match the local repository
- Celebrate your success with some fancy beverage(s)
- Update local repository to match the remote repository
- Stage changes to be committed
- Commit changes to the local repository
In what order should you perform these actions to minimize the chances of conflicts? Put the commands above in order in the action column of the table below. When you have the order right, see if you can write the corresponding commands in the command column. A few steps are populated to get you started.
order | action . . . . . . . . . . | command . . . . . . . . . . |
---|---|---|
1 | ||
2 | echo 100 >> numbers.txt |
|
3 | ||
4 | ||
5 | ||
6 | Celebrate! | AFK |
order | action . . . . . . | command . . . . . . . . . . . . . . . . . . . |
---|---|---|
1 | Update local | git pull origin main |
2 | Make changes | echo 100 >> numbers.txt |
3 | Stage changes | git add numbers.txt |
4 | Commit changes | git commit -m "Add 100 to numbers.txt" |
5 | Update remote | git push origin main |
6 | Celebrate! | AFK |
Content from Open Science
Last updated on 2023-06-13 | Edit this page
Estimated time 10 minutes
Overview
Questions
- How can version control help me make my work more open?
Objectives
- Explain how a version control system can be leveraged as an electronic lab notebook for computational work.
The opposite of “open” isn’t “closed”. The opposite of “open” is “broken”.
-– John Wilbanks
Free sharing of information might be the ideal in science, but the reality is often more complicated. Normal practice today looks something like this:
- A scientist collects some data and stores it on a machine that is occasionally backed up by their department.
- They then write or modify a few small programs (which also reside on the machine) to analyze that data.
- Once they have some results, they write them up and submit a paper. The scientist might include their data – a growing number of journals require this – but they probably don’t include the code.
- Time passes.
- The journal sends the scientist reviews written anonymously by a handful of other people in their field. The scientist revises the paper to satisfy the reviewers, during which time they might also modify the scripts they wrote earlier, and resubmits.
- More time passes.
- The paper is eventually published. It might include a link to an online copy of the data, but the paper itself will be behind a paywall: only people who have personal or institutional access will be able to read it.
For a growing number of scientists, though, the process looks like this:
- The data that the scientist collects is stored in an open access repository like figshare or Zenodo, possibly as soon as it’s collected, and given its own Digital Object Identifier (DOI). Or the data was already published and is stored in Dryad.
- The scientist creates a new repository on GitHub to hold their work.
- During analysis, they push changes to their scripts (and possibly some output files) to that repository. The scientist also uses the repository for their paper; that repository is then the hub for collaboration with colleagues.
- When they are happy with the state of the paper, the scientist posts a version to arXiv or some other preprint server to invite feedback from peers.
- Based on that feedback, they may post several revisions before finally submitting the paper to a journal.
- The published paper includes links to the preprint and to the code and data repositories, which makes it much easier for other scientists to use their work as starting point for their own research.
This open model accelerates discovery: the more open work is, the more widely it is cited and re-used. However, people who want to work this way need to make some decisions about what exactly “open” means and how to do it. You can find more on the different aspects of Open Science in this book.
This is one of the (many) reasons we teach version control. When used diligently, it answers the “how” question by acting as a shareable electronic lab notebook for computational work:
- The conceptual stages of your work are documented, including who did what and when. Every step is stamped with an identifier (the commit ID) that is for most intents and purposes unique.
- You can tie documentation of rationale, ideas, and other intellectual work directly to the changes that spring from them.
- You can refer to what you used in your research to obtain your computational results in a way that is unique and recoverable.
- With a version control system such as Git, the entire history of the repository is easy to archive for perpetuity.
Making Code Citable
Anything that is hosted in a version control repository (data, code, papers, etc.) can be turned into a citable object. You’ll learn how to do this in the later episode on Citation.
How to Find an Appropriate Data Repository?
Surf the internet for a couple of minutes and check out the data repositories mentioned above: Figshare, Zenodo, Dryad. Depending on your field of research, you might find community-recognized repositories that are well-known in your field. You might also find useful these data repositories recommended by Nature. Discuss with your neighbor which data repository you might want to approach for your current project and explain why.
How to Track Large Data or Image Files using Git?
Large data or image files such as .md5
or
.psd
file types can be tracked within a github repository
using the Git Large File
Storage open source extension tool. This tool automatically uploads
large file contents to a remote server and replaces the file with a text
pointer within the github repository.
Try downloading and installing the Git Large File Storage extension tool, then add tracking of a large file to your github repository. Ask a colleague to clone your repository and describe what they see when they access that large file.
Content from Licensing
Last updated on 2023-06-13 | Edit this page
Estimated time 5 minutes
Overview
Questions
- What licensing information should I include with my work?
Objectives
- Explain why adding licensing information to a repository is important.
- Choose a proper license.
- Explain differences in licensing and social expectations.
When a repository with source code, a manuscript or other creative
works becomes public, it should include a file LICENSE
or
LICENSE.txt
in the base directory of the repository that
clearly states under which license the content is being made available.
This is because creative works are automatically eligible for
intellectual property (and thus copyright) protection. Reusing creative
works without a license is dangerous, because the copyright holders
could sue you for copyright infringement.
A license solves this problem by granting rights to others (the licensees) that they would otherwise not have. What rights are being granted under which conditions differs, often only slightly, from one license to another. In practice, a few licenses are by far the most popular, and choosealicense.com will help you find a common license that suits your needs. Important considerations include:
- Whether you want to address patent rights.
- Whether you require people distributing derivative works to also distribute their source code.
- Whether the content you are licensing is source code.
- Whether you want to license the code at all.
Choosing a license that is in common use makes life easier for contributors and users, because they are more likely to already be familiar with the license and don’t have to wade through a bunch of jargon to decide if they’re ok with it. The Open Source Initiative and Free Software Foundation both maintain lists of licenses which are good choices.
This article provides an excellent overview of licensing and licensing options from the perspective of scientists who also write code.
At the end of the day what matters is that there is a clear statement as to what the license is. Also, the license is best chosen from the get-go, even if for a repository that is not public. Pushing off the decision only makes it more complicated later, because each time a new collaborator starts contributing, they, too, hold copyright and will thus need to be asked for approval once a license is chosen.
What licenses have I already accepted?
Many of the software tools we use on a daily basis (including in this
workshop) are released as open-source software. Pick a project on GitHub
from the list below, or one of your own choosing. Find its license
(usually in a file called LICENSE
or COPYING
)
and talk about how it restricts your use of the software. Is it one of
the licenses discussed in this session? How is it different?
Keypoints
- The
LICENSE
,LICENSE.md
, orLICENSE.txt
file is often used in a repository to indicate how the contents of the repo may be used by others. - People who incorporate General Public License (GPL’d) software into their own software must make their software also open under the GPL license; most other open licenses do not require this.
- The Creative Commons family of licenses allow people to mix and match requirements and restrictions on attribution, creation of derivative works, further sharing, and commercialization.
- People who are not lawyers should not try to write licenses from scratch.
Content from Citation
Last updated on 2023-06-13 | Edit this page
Estimated time 2 minutes
Overview
Questions
- How can I make my work easier to cite?
Objectives
- Make your work easy to cite
You may want to include a file called CITATION
or
CITATION.txt
that describes how to reference your project;
the one
for Software Carpentry states:
To reference Software Carpentry in publications, please cite both of the following:
Greg Wilson: "Software Carpentry: Getting Scientists to Write Better
Code by Making Them More Productive". Computing in Science &
Engineering, Nov-Dec 2006.
Greg Wilson: "Software Carpentry: Lessons Learned". arXiv:1307.5448,
July 2013.
@article{wilson-software-carpentry-2006,
author = {Greg Wilson},
title = {Software Carpentry: Getting Scientists to Write Better Code by Making Them More Productive},
journal = {Computing in Science \& Engineering},
month = {November--December},
year = {2006},
}
@online{wilson-software-carpentry-2013,
author = {Greg Wilson},
title = {Software Carpentry: Lessons Learned},
version = {1},
date = {2013-07-20},
eprinttype = {arxiv},
eprint = {1307.5448}
}
More detailed advice, and other ways to make your code citable can be found at the Software Sustainability Institute blog and in:
Smith AM, Katz DS, Niemeyer KE, FORCE11 Software Citation Working Group. (2016) Software citation
principles. [PeerJ Computer Science 2:e86](https://peerj.com/articles/cs-86/)
https://doi.org/10.7717/peerj-cs.8
There is also an @software{...
BibTeX entry type in case
no “umbrella” citation like a paper or book exists for the project you
want to make citable.
Content from Hosting
Last updated on 2023-11-14 | Edit this page
Estimated time 10 minutes
Overview
Questions
- Where should I host my version control repositories?
Objectives
- Explain different options for hosting scientific work.
The second big question for groups that want to open up their work is where to host their code and data. One option is for the lab, the department, or the university to provide a server, manage accounts and backups, and so on. The main benefit of this is that it clarifies who owns what, which is particularly important if any of the material is sensitive (i.e., relates to experiments involving human subjects or may be used in a patent application). The main drawbacks are the cost of providing the service and its longevity: a scientist who has spent ten years collecting data would like to be sure that data will still be available ten years from now, but that’s well beyond the lifespan of most of the grants that fund academic infrastructure.
Another option is to purchase a domain and pay an Internet service provider (ISP) to host it. This gives the individual or group more control, and sidesteps problems that can arise when moving from one institution to another, but requires more time and effort to set up than either the option above or the option below.
The third option is to use a public hosting service like GitHub, GitLab, or BitBucket. Each of these services provides a web interface that enables people to create, view, and edit their code repositories. These services also provide communication and project management tools including issue tracking, wiki pages, email notifications, and code reviews. These services benefit from economies of scale and network effects: it’s easier to run one large service well than to run many smaller services to the same standard. It’s also easier for people to collaborate. Using a popular service can help connect your project with communities already using the same service.
As an example, Software Carpentry is on GitHub where you can find the source for this page. Anyone with a GitHub account can suggest changes to this text.
GitHub repositories can also be assigned DOIs, by connecting
its releases to Zenodo. For example, 10.5281/zenodo.7908089
is the DOI that has been “minted” for this introduction to Git.
Using large, well-established services can also help you quickly take advantage of powerful tools. One such tool, continuous integration (CI), can automatically run software builds and tests whenever code is committed or pull requests are submitted. Direct integration of CI with an online hosting service means this information is present in any pull request, and helps maintain code integrity and quality standards. While CI is still available in self-hosted situations, there is much less setup and maintenance involved with using an online service. Furthermore, such tools are often provided free of charge to open source projects, and are also available for private repositories for a fee.
Institutional Barriers
Sharing is the ideal for science, but many institutions place restrictions on sharing, for example to protect potentially patentable intellectual property. If you encounter such restrictions, it can be productive to inquire about the underlying motivations and either to request an exception for a specific project or domain, or to push more broadly for institutional reform to support more open science.
Content from Supplemental: Using Git from RStudio
Last updated on 2023-11-14 | Edit this page
Estimated time 10 minutes
Overview
Questions
- How can I use Git with RStudio?
Objectives
- Understand how to use Git from RStudio.
Version control can be very useful when developing data analysis scripts. For that reason, the popular development environment RStudio for the R programming language has built-in integration with Git. While some advanced Git features still require the command-line, RStudio has a nice interface for many common Git operations.
RStudio allows us to create a project associated with a given directory to keep track of various related files. To be able to track the development of the project over time, to be able to revert to previous versions, and to collaborate with others, we version control the Rstudio project with Git. To get started using Git in RStudio, we create a new project:
This opens a dialog asking us how we want to create the project. We have some options here. Let’s say that we want to use RStudio with the planets repository that we already made. Since that repository lives in a directory on our computer, we choose the option “Existing Directory”:
Do You See a “Version Control” Option?
Although we’re not going to use it here, there should be a “version control” option on this menu. That is what you would click on if you wanted to create a project on your computer by cloning a repository from GitHub. If that option is not present, it probably means that RStudio doesn’t know where your Git executable is, and you won’t be able to progress further in this lesson until you tell RStudio where it is.
Find your Git Executable
First let’s make sure that Git is installed on your computer. Open your shell on Mac or Linux, or on Windows open the command prompt and then type:
-
which git
(macOS, Linux) -
where git
(Windows)
If there is no version of Git on your computer, please follow the Git
installation instructions in the setup of this lesson to install Git
now. Next open your shell or command prompt and type
which git
(macOS, Linux), or where git
(Windows). Copy the path to the git executable.
On one Windows computer which had GitHub Desktop installed on it, the
path was:
C:/Users/UserName/AppData/Local/GitHubDesktop/app-1.1.1/resources/app/git/cmd/git.exe
NOTE: The path on your computer will be somewhat different.
Next, RStudio will ask which existing directory we want to use. Click “Browse…” and navigate to the correct directory, then click “Create Project”:
Ta-da! We have created a new project in RStudio within the existing planets repository. Notice the vertical “Git” menu in the menu bar. RStudio has recognized that the current directory is a Git repository, and gives us a number of tools to use Git:
To edit the existing files in the repository, we can click on them in the “Files” panel on the lower right. Now let’s add some additional information about Pluto:
Once we have saved our edited files, we can use RStudio to commit the changes by clicking on “Commit…” in the Git menu:
This will open a dialogue where we can select which files to commit
(by checking the appropriate boxes in the “Staged” column), and enter a
commit message (in the upper right panel). The icons in the “Status”
column indicate the current status of each file. Clicking on a file
shows information about changes in the lower panel (using output of
git diff
). Once everything is the way we want it, we click
“Commit”:
The changes can be pushed by selecting “Push Branch” from the Git menu. There are also options to pull from the remote repository, and to view the commit history:
If we click on “History”, we can see a graphical version of what
git log
would tell us:
RStudio creates a number of files that it uses to keep track of a
project. We often don’t want to track these, in which case we add them
to our .gitignore
file:
This can be done in Rstudio:
R
dir.create("./graphs")
Then open up the .gitignore
file from the right-hand
panel of Rstudio and add graphs/
to the list of files to
ignore.
There are many more features in the RStudio Git menu, but these should be enough to get you started!
Content from Setting up a Python Project
Last updated on 2023-11-14 | Edit this page
Estimated time 25 minutes
Overview
Questions
- How should I structure a Python project?
- How can I test my code to prevent bugs?
Objectives
- Make our repository follow a ‘standard’ Python project format
- Add a test and testing framework
- Run the tests and a linter on GitLab - using a branch and a Pull Request
Structuring a Project
Vlad and Wolfsman are still investigating how to send a planetary lander to Mars and other planets or moons. They need to start crunching numbers and they decided to start a Python project.
Mars by European Space Agency / CC-BY-SA 3.0 IGO. Pluto / Courtesy NASA/JPL-Caltech. Moon © Luc Viatour / https://lucnix.be / CC BY-SA 3.0. Spacecraft CC 0.
Most Python projects are structured in a similar way. There are very good reasons for this - if you follow the ‘standard’, other people who approach your code will recognise parts of it and will know by default how to install your code, run any tests that might exist, and where to look for source code or to change things like the dependencies that are required.
The following is a simple Python project with a typical structure
(the .git
directory is omitted):
OUTPUT
planetsmath/
├── DEVELOPMENT.md
├── .editorconfig
├── .github
│ └── workflows
│ ├── linters.yaml
│ └── pytest.yaml
├── .gitignore
├── LICENSES
│ └── Apache-2.0.txt
├── LICENSE.txt
├── .pre-commit-config.yaml
├── .pylintrc
├── README.md
├── requirements.txt
├── .reuse
│ ├── dep5
│ └── templates
│ └── compact.jinja2
├── setup.py
└── src
└── planetsmath
├── functions.py
├── __init__.py
└── test_functions.py
You can see this sample project here and clone it with (assumin you use CLI and HTTPS):
BASH
$ git clone https://github.com/mambelli/planetsmath.git
If using SSH:
BASH
$ git clone git@github.com:mambelli/planetsmath.git
We’ll talk of these folders/files one at a time:
planetsmath/
Inside the project source tree we normally have a folder which matches the name of the Python module. This is done so that from the src directory, the code within the module can be imported with:
PYTHON
import planetsmath
You can see this for e.g. in the source repository of the NumPy library.
Within this folder, we can store code files (e.g. functions.py) and further subdirectories. These will then be importable too.
functions.py
This is just a standard Python file with methods in it. You can have
as many of these as you like, but generally people organise them around
what the code is doing. So for e.g if you have a few methods that deal
with I/O, you might create a file called io.py
and put all
of those methods there. Organising your code across multiple files like
this is a very good idea - it makes it easier to find things.
__init__.py
The __init__.py
file is effectively as set of
instructions that get run when you import a Python module. So with a
blank __init__.py
, nothing happens if you run
import planetsmath
in a Python session. If you want to use
methods from the functions.py file. What is common is to import certain
methods into the top level of the module, for e.g.:
PYTHON
from .functions import sum_function
Then, in a Python session, you would be able to do the following:
PYTHON
>>> import planetsmath
>>> planetsmath.sum_function([1, 2, 3, 4])
10
setup.py
A setup.py file is just a list of instructions for Python that tell it how to install your package, and what it’s made up of. There are a myriad of options, but a very simple one for this project could be:
PYTHON
from setuptools import setup
setup(='planets',
name='0.0.1',
version=['planetsmath'],
packages=[
install_requires'numpy',
], )
Notice that there is a section called ‘install_requires’. This isn’t required for our package, as we’re not using NumPy, but it is very common to see a list of external packages here. On install with pip, Python will check to see if it can import ‘numpy’ and ‘matplotlib’. If it can’t, the installation will fail.
requirements.txt
This is just a text file where you can put any dependencies your package needs to work. If necessary, you can constrain some of your package dependencies to specific versions, for e.g.:
OUTPUT
pytest
numpy>=1.21.4
To install all of the dependencies, you can run
pip install -r requirements.txt
. This is well known by most
people working with Python. Generally you should try to install things
via pip like this, and not via Anaconda (unless you have no choice).
This is because Anaconda is less portable: - Is not usable by commercial
organisations without a paid for license. This matters if you have
external companies as collaborators - Was introduced mainly for
distributing compiled dependencies. This is now well handled by pip with
the introduction of wheels
- Anaconda is not usable or is
heavily discouraged on many HPC clusters.
README.md
This file offers general information about the project. It is the one displayed by GitHub at the end of the code page. It is possible to add badges with the status of the CI tests.
Other files
-
DEVELOPMENT.md
: instructions for collaborators and your future self. -
LICENSE.txt
(and.reuse
andLICENSES
): it’s the common place for your project’s license, seen also in the licensing episode, very important when making your code public. See the Licensing compliance section below for a complete licensing solution : reuse can establish and verify licensing complaiance. -
src/planetsmath/test_functions.py
: unit tests forfunctions.py
, see the (testing section)[# GitHub CI: unit tests and linting] below.
Hidden files, visible with ls -a
: -
.editorconfig
: joint comfiguration recognized by many
different editors - .git
and .gitignore
: Git
internal files, seen in the Creating a
repository and Ignoring Things episodes
respectively - .github
directory: contains GitHub
automation files, see the testing and
GitHub CI section below. - .pre-commit-config.yaml
:
pre-commit configuration file, see the next section. -
.pylintrc
: configuration file of pylint, a python
linter
Adding Pre-commit checks
It is possible to run some checks before each commit command, taking advantage of the hooks mechanism in Git. A pre-commit will guarantee that committed code always follows the desired standard. To start using pre-commit you have to add a pre-commit config file and to install pre-commit.
Add a pre-commit config file named
.pre-commit-config.yaml
with the following content for an
initial set of checks:
YAML
# For more information see
# https://pre-commit.com/index.html#install
# https://pre-commit.com/index.html#automatically-enabling-pre-commit-on-repositories
default_language_version:
# force all unspecified python hooks to run python3
python: python3
repos:
- repo: "https://github.com/pre-commit/pre-commit-hooks"
rev: v4.1.0
hooks:
- id: check-ast
- id: check-docstring-first
- id: check-toml
- id: check-merge-conflict
- id: check-yaml
- id: end-of-file-fixer
- id: fix-byte-order-marker
- id: mixed-line-ending
- id: trailing-whitespace
args:
- "--markdown-linebreak-ext=md"
- repo: "https://github.com/pre-commit/pygrep-hooks"
rev: v1.9.0
hooks:
- id: python-check-blanket-noqa
- id: python-check-blanket-type-ignore
- id: python-use-type-annotations
- repo: "https://github.com/pycqa/isort"
rev: 5.10.1
hooks:
- id: isort
- repo: "https://github.com/psf/black"
rev: 22.3.0
hooks:
- id: black
- repo: "https://github.com/pre-commit/mirrors-prettier"
rev: v2.6.2
hooks:
- id: prettier
exclude_types:
- "python"
additional_dependencies:
- "prettier"
- "prettier-plugin-toml@0.3.1"
- repo: "https://github.com/asottile/pyupgrade"
rev: v2.31.0
hooks:
- id: pyupgrade
args:
- "--py36-plus"
- repo: "https://github.com/fsfe/reuse-tool"
rev: v0.14.0
hooks:
- id: reuse
additional_dependencies:
- python-debian==0.1.40
To install it run from the repository root:
BASH
pre-commit install
You may want to setup automatic notifications for pre-commit enabled
repos. This will suggest updates to your
.pre-commit-config.yaml
: https://pre-commit.com/index.html#automatically-enabling-pre-commit-on-repositories
You can also run pre-commit manually to check all the files:
BASH
pre-commit run --all-files
Licensing compliance
Planets Math is released under the Apache 2.0 license and license
compliance is handled with the REUSE tool. REUSE is installed as
development dependency or you can install it manually
(pip install reuse
). All files should have a license
notice:
to check compliance you can use
reuse lint
. This is the command run also by the pre-commit and CI checks-
you can add on top of new files SPDX license notices like
# SPDX-FileCopyrightText: 2022 Fermi Research Alliance, LLC # SPDX-License-Identifier: Apache-2.0
-
or let REUSE do that for you (
FILEPATH
is your new file):BASH
reuse addheader --year 2023 --copyright="Fermi Research Alliance, LLC" \ --license="Apache-2.0" --template=compact FILEPATH
Files that are not supported and have no comments to add the SPDX notice can be added to the
.reuse/dep5
fileNew licenses can be added to the project using
reuse download LCENSEID
. Please contact project management if this is needed.
GitHub CI: unit tests and linting
First, we’ll introduce a new file. In the
src/planetsmath
subdirectory, in a file called
test_functions.py
we can write any tests of methods in
functions.py
. The library pytest
is commonly
used for unit tests like this. Pytest can pick up tests written in the
following way:
PYTHON
from .functions import sum_function
def test_sum_function():
assert sum_function([1, 2, 3, 4, 5]) == 15.0
assert sum_function([1, 2.2, 3, 4, 5]) == 15.2
assert sum_function([-1, 2, 3, 4, 5]) == 13
Note that both the file name and the method inside have the same name
of the module and function they wasnt to test, but are preceded with
test_
- this is compulsory!
With this, when pytest is installed, you can run ‘py.test -v’ at the command line, and all of your tests will run. With unit tests like this, you can check your code for correctness.
Next, create a file called .github/workflows/pytest.yaml
with the following content:
YAML
# SPDX-FileCopyrightText: 2022 Fermi Research Alliance, LLC
# SPDX-License-Identifier: Apache-2.0
---
name: PyTest
on:
push:
branches:
- "**" # matches every branch
pull_request:
branches:
- main
jobs:
run_linters:
name: Run unit test against code tree
runs-on: ubuntu-latest
steps:
- name: checkout code tree
uses: actions/checkout@v2
- name: Set up Python 3.7
uses: actions/setup-python@v2
with:
python-version: "3.7"
architecture: "x64"
- name: Install dependencies
run: |
python3 -m pip install --upgrade pip
if [ -f requirements.txt ]; then python3 -m pip install -r requirements.txt; fi - name: Unit test
env:
PYTHONPATH: ${{ github.workspace }}/src
run: |
python3 -m pytest --import-mode=append src
This is a basic recipe that will allow your tests to run on GitHub. Add both of these files to your staging area and commit them, and then push to GitHub.
The planetsmath
example includes a second CI
configuration file, to run common Python linters.
Keypoints
- While there is often variation, most Python projects follow a similar structure for their code
- Doing so is beneficial because it allows components of your code to be reused more easily by yourself and others
- Testing can be ‘automatic’ rather than manual. This catches many issues before they become a problem - this is continuous integration
- The concepts here can be used for all programming languages - not just Python - and are pretty much universally used by professional software developers
Content from Collaborating - Branching and Pull Requests
Last updated on 2023-06-13 | Edit this page
Estimated time 25 minutes
Overview
Questions
- How can I use version control to collaborate with other people more effectively?
Objectives
- Create a branch
- Push the branch to a repository
- Make a pull request to the repository
Often, we want to work on a set of changes that are more complicated than what was shown in the last lesson, and without affecting other people’s work. Think for example, what would happen if I made a change to code that someone else was using, but left it in a broken state. They would probably not be very happy with me! To this effect, we can use a concept called ‘branches’ to separate works-in-progress from the known ‘good’ copy of the code. In general, it’s considered good practice to create a branch for every piece of work that you do, and to merge these into the ‘good’ version regularly.
Forking a repository
Frequently you may not have write access to a Git repository or we may want to have more control on how the changes get merged in that repository. So we create our own personal copy of the repository, linked to the original one. This is called a ‘forked’ repository, frequently but not always it has the same name of the original repository.
To create a fork go on GitHub to the page of the repository you’d
like to fork, e.g. https://github.com/vlad/planets.git
,
then click on the ‘fork’ button, close to the top roght of the windows:
A new page will let you choose the details of the fork: - the owner, you or one of your organizations - the name of the repository, by default the same as the forked repository (unless there is a conflict in your space)
Let’s say you are wolfsman and forked the repository maintaining the name. Now you can clone your personal copy:
BASH
$ git clone git@github.com:wolfsman/planets.git ~/Desktop/planets
Creating a new branch with changes
To create a new branch, run the following command in your repository:
BASH
$ git checkout -b add-square-array-method
OUTPUT
Switched to a new branch 'add-square-array-method'
This creates a separate area for us to work in and add changes. It’s a bit like how we cloned the repository in a separate place in the last lesson. However, we can also push our branch to the remote repository and keep it backed up.
We’ll add a function that takes in a list, and squares all of the
elements in it, returning a new array. In the
src/planetsmath/
directory:
BASH
$ nano functions.py
$ tail -n 2 functions.py
OUTPUT
def square_array(list):
return [item*item for item in list]
Then we’ll commit it as normal:
BASH
$ git add functions.py
$ git commit -m "Add a method that squares a list"
OUTPUT
[add-square-array-method ea4141e] Add a method that squares a list
1 file changed, 4 insertions(+)
Notice now that instead of saying ‘main’ here, it says ‘add-square-array-method’, showing us that our commit is on our branch. We’ve sort of glossed over it previously, but ‘main’ is the “default branch” in Git. In some older git versions this was named ‘master’, so you may see this instead.
Our commit is now saved in our local repository. If you want to, you can switch back to the ‘main’ branch by doing:
BASH
git checkout main
OUTPUT
Switched to branch 'main'
If you now print the file, you’ll see that our new method isn’t there:
BASH
cat functions.py
OUTPUT
# SPDX-FileCopyrightText: 2022 Fermi Research Alliance, LLC
# SPDX-License-Identifier: Apache-2.0
def sum_function(list):
"""
A function which takes a list as an argument and
returns the sum
Parameters
----------
list: list
Must be floats or ints
Returns
-------
float:
The sum of the elements in list
"""
sum = 0.0
for item in list:
sum += item
return sum
def sum_product(list):
product = 1.0
for item in list:
product *= item
return product
Pushing a new branch
We’ll switch back to our branch again:
BASH
$ git checkout add-square-array-method
OUTPUT
Switched to branch 'add-square-array-method'
We can put our changes onto GitHub by pushing it. However, if you run
git push
, it won’t immediately work:
BASH
$ git push
OUTPUT
fatal: The current branch add-square-array-method has no upstream branch.
To push the current branch and set the remote as upstream, use
git push --set-upstream origin add-square-array-method
This message just means that the remote doesn’t have a branch called add-square-array-method to push our work to. We can create one in our push just by running the command it gives us:
BASH
$ git push --set-upstream origin add-square-array-method
OUTPUT
Enumerating objects: 9, done.
Counting objects: 100% (9/9), done.
Delta compression using up to 8 threads
Compressing objects: 100% (4/4), done.
Writing objects: 100% (5/5), 460 bytes | 460.00 KiB/s, done.
Total 5 (delta 3), reused 0 (delta 0), pack-reused 0
remote: Resolving deltas: 100% (3/3), completed with 3 local objects.
remote:
remote: Create a pull request for 'add-square-array-method' on GitHub by visiting:
remote: https://github.com/wolfsman/planetsmath/pull/new/add-square-array-method
remote:
To https://github.com/wolfsman/planetsmath.git
* [new branch] add-square-array-method -> add-square-array-method
Branch 'add-square-array-method' set up to track remote branch 'add-square-array-method' from 'origin'.
This slightly convoluted message tells us that:
- A new branch was created on the remote GitHub version of the repository
- Our local copy is associated with the remote branch
- We pushed that commit
- We can easily create a pull request following the link provided
- Our repository is a fork of another repository and the changes can be fed upstream by opening a Pull Request (see the next section)
New changes can be added and then pushed to the branch just by
running the standard commit and push commands now. It’s worth noting
that git push
only applies to the branch that you are
currently working on - if you make changes on “main”, then switch to the
“add-square-array-method” and run git push
, the main
changes will not be uploaded to GitHub.
On GitHub, you can switch branches by using the little drop down menu:
Add branch protection rules (requirements) in the base repository
To avoid undesired changes in the base repository usually administrators will add restrictions, e.g.: - block regular merges (not using a PR) - require at least one review before a Pull Request can be merged - require status check to pass before merging
To set these requirements go to the original repository, in the “Settings” tab (the last on the right) select “Branches” from the menu on the left and under “Branch protection rules” you can press “Add rule” to add a new one or you can edit existing ones. Either ways you can click on the restrictions you’d like to enable.
Pull (Merge) Requests
Pull requests can be used at this point to put the changes on the ‘main’ copy of the repository.
The easiest way to open a pull request is to use the URL suggested by
Git, like
https://github.com/wolfsman/planetsmath/pull/new/add-square-array-method
at the end of the previos section. Alternatively, go back to your
personal repository on GitHub and since it is the result of a fork, it
will have a pull-down “Contribute” that allows to “Open pull request”:
Either way you’ll get to a window where you can review and create the pull request. The dialogue is pre-populated probably with the correct values, anyway you can use dropboxes pick the source and destination repository and branch, and a title and description (similar to the comments in the Git commits). There are quite a few options. You should generally write a description that tells you what the changes are. If you are working on a project with other people, ‘Assignees’ are people who will be implementing changes (i.e. you) and reviewers are people who will check your work for any mistakes, code that could be written more elegantly, etc. - it is very good practice to get your code reviewed before merging and a GitHub project can also require that. Finally you can compare the content and open the pull request:
The Pull Request will be open in the base repository and you and the project members will be able to have a conversation about the changes you submitted. There are 4 tabs in a Pull Request page: - Conversation, summarizes the interactions and allows communications between the submitter and reviewers - Commits, a list of Git commits included in this PR - Checks, the result of automatic tests - Files changed, a diff between the upstream branch and the one with the changes. This is the tab that can be used to comment the code and to ask for changes or approve the code.
A reviewer can highlight lines on the “Files changed” tab and add comments to request changes. General comments can be added directly in the “Conversation” tab.
A reviewer could also edit a file directly in the PR (i.e. in the branch that will be merged in the repository (the submitter can block this if desired). GitHub allows to edit files and commit changes directly on the Web. Convenient if the changes are small.
Finally the files are feady and a reviewer can approve the PR.
At this point someone with write permission on the repository can merge the PR. There are three options: - Create a merge commit: Preserves the original history of all commits. - Squash and merge: Useful if the PR has meany commits not so meaningful. Remember to write a commit message capturing all the changes - Rebase and merge: The most common if the PR branch was not shared or the base of other branches; adds all the commits on top after a rebase
Choose the most appropriate and complete the merge. Frequently GitHub will ask to confirm the merge action.
At this point the changes have been incorporated in the destination branch, in the original repository. You can verify that inspecting the files.
The source branch of the PR can be deleted.
Keeping up with upstream changes
Assuming that you are working on a project with many other collaborators, the main repository will change frequently.
To keep your fork in sync, GitHub has a “Sync fork” pull-down in the status bar before your code (the same one where the contribute pull-down is). In it there is a green “Update branch” button that allows you to rebase your code to the upstream content. Then you can push updated local copuies. This process is fairly straight forward, especially if you keep your main/master branch as a mirror of the upstream one and do all your contribution in separate feature branches.
Alternatively, you cn manage both your fork and the upstream repo as remotes in a local clone and manually pull and rebase as desired. This gives you more control but may be more complex.
Comment Changes in GitHub
The Collaborator has some questions about one line change made by the Owner and has some suggestions to propose.
With GitHub, it is possible to comment on the diff of a commit. Over the line of code to comment, a blue comment icon appears to open a comment window.
The Collaborator posts her comments and suggestions using the GitHub interface.