diff --git a/01-basics.md b/01-basics.md new file mode 100644 index 0000000000..6633f92053 --- /dev/null +++ b/01-basics.md @@ -0,0 +1,127 @@ +--- +title: Automated Version Control +teaching: 5 +exercises: 0 +--- + +::::::::::::::::::::::::::::::::::::::: objectives + +- Understand the benefits of an automated version control system. +- Understand the basics of how automated version control systems work. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: questions + +- What is version control and why should I use it? + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +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: + +!["notFinal.doc" by Jorge Cham, ](fig/phd101212s.png){alt='Comic: a PhD student sends "FINAL.doc" to their supervisor, but after several increasingly intense and frustrating rounds of comments and revisions they end up with a file named "FINAL_rev.22.comments49.corrections.10.#@$%WHYDIDCOMETOGRADSCHOOL????.doc"'} + +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](https://support.office.com/en-us/article/Track-changes-in-Word-197ba630-0f5f-4a8e-9a77-3712475e806a), +Google Docs' [version history](https://support.google.com/docs/answer/190843?hl=en), or +LibreOffice's [Recording and Displaying Changes](https://help.libreoffice.org/Common/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. + +![](fig/play-changes.svg){alt='A diagram demonstrating how a single document grows as the result of sequential changes'} + +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. + +![](fig/versions.svg){alt='A diagram with one source document that has been modified in two different ways to produce two different versions of the document'} + +Unless multiple users make changes to the same section of the document - a +[conflict](../learners/reference.md#conflict) - you can +incorporate two sets of changes into the same base document. + +![](fig/merge.svg){alt='A diagram that shows the merging of two different document versions into one document that contains all of the changes from both versions'} + +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](../learners/reference.md#commit)), and keeps useful metadata +about them. The complete history of commits for a particular project and their +metadata make up a [repository](../learners/reference.md#repository). +Repositories can be kept in sync across different computers, facilitating +collaboration among different people. + +::::::::::::::::::::::::::::::::::::::::: callout + +## The Long History of Version Control Systems + +Automated version control systems are nothing new. +Tools like [RCS](https://en.wikipedia.org/wiki/Revision_Control_System), [CVS](https://en.wikipedia.org/wiki/Concurrent_Versions_System), or [Subversion](https://en.wikipedia.org/wiki/Apache_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](https://swcarpentry.github.io/hg-novice/), +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. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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? + +::::::::::::::: solution + +## Solution + +- 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. + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: keypoints + +- Version control is like an unlimited 'undo'. +- Version control also allows many people to work in parallel. + +:::::::::::::::::::::::::::::::::::::::::::::::::: diff --git a/02-setup.md b/02-setup.md new file mode 100644 index 0000000000..2f23b88528 --- /dev/null +++ b/02-setup.md @@ -0,0 +1,225 @@ +--- +title: Setting Up Git +teaching: 5 +exercises: 0 +--- + +::::::::::::::::::::::::::::::::::::::: objectives + +- Configure `git` the first time it is used on a computer. +- Understand the meaning of the `--global` configuration flag. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: questions + +- How do I get set up to use Git? + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +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](https://github.com/), +[BitBucket](https://bitbucket.org/), +[GitLab](https://gitlab.com/) or +another Git host server +after this lesson will include this information. + +For this lesson, we will be interacting with [GitHub](https://github.com/) 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][git-privacy]. + +::::::::::::::::::::::::::::::::::::::::: callout + +## Keeping your email private + +If you elect to use a private email address with GitHub, then use GitHub's no-reply email address for the `user.email` value. It looks like `ID+username@users.noreply.github.com`. You can look up your own address in your GitHub [email settings](https://github.com/settings/emails). + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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](https://www.git-scm.com/book/en/v2/Customizing-Git-Git-Configuration#_core_autocrlf). + +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. + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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 +``` + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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](https://github.com/github/renaming) 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. + +::::::::::::::::::::::::::::::::::::::::: callout + +## Proxy + +In some networks you need to use a +[proxy](https://en.wikipedia.org/wiki/Proxy_server). 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 +``` + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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 -h` or access the corresponding Git manual by typing +`git --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 +``` + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +[git-privacy]: https://help.github.com/articles/keeping-your-email-address-private/ + + +:::::::::::::::::::::::::::::::::::::::: keypoints + +- Use `git config` with the `--global` option to configure a user name, email address, editor, and other preferences once per machine. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + + diff --git a/03-create.md b/03-create.md new file mode 100644 index 0000000000..3cf285bc4b --- /dev/null +++ b/03-create.md @@ -0,0 +1,215 @@ +--- +title: Creating a Repository +teaching: 10 +exercises: 0 +--- + +::::::::::::::::::::::::::::::::::::::: objectives + +- Create a local Git repository. +- Describe the purpose of the `.git` directory. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: questions + +- Where does Git store information? + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +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. + +![](fig/motivatingexample.png){alt='The main elements of the story: Dracula, Wolfman, the Mummy, Mars, Pluto and The Moon'} +[Werewolf vs dracula](https://www.deviantart.com/b-maze/art/Werewolf-vs-Dracula-124893530) +by [b-maze](https://www.deviantart.com/b-maze) / [Deviant Art](https://www.deviantart.com/). +[Mars](https://en.wikipedia.org/wiki/File:OSIRIS_Mars_true_color.jpg) by European Space Agency / +[CC-BY-SA 3.0 IGO](https://creativecommons.org/licenses/by/3.0/deed.en). +[Pluto](https://commons.wikimedia.org/wiki/File:PIA19873-Pluto-NewHorizons-FlyingPastImage-20150714-transparent.png) / +Courtesy NASA/JPL-Caltech. +[Mummy](https://commons.wikimedia.org/wiki/File:Mummy_icon_-_Noun_Project_4070.svg) +© Gilad Fried / [The Noun Project](https://thenounproject.com/) / +[CC BY 3.0](https://creativecommons.org/licenses/by/3.0/deed.en). +[Moon](https://commons.wikimedia.org/wiki/File:Lune_ico.png) +© Luc Viatour / [https://lucnix.be](https://lucnix.be/) / +[CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/deed.en). + +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](../learners/reference.md#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](02-setup.md#default-git-branch-naming) for more information on this change. + +```bash +$ git checkout -b main +``` + +```output +Switched to a new branch 'main' +``` + +We can now start using one of the most important git commands, which is particularly helpful to beginners. `git status` tells us the status of our project, and better, a list of changes in the project and options on what to do with those changes. We can use it as often as we want, whenever we want to understand what is going on. + +```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. + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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? + +::::::::::::::: solution + +## Solution + +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 +``` + +::::::::::::::::::::::::: + +## Correcting `git init` Mistakes + +Wolfman explains to Dracula how a nested repository is redundant and may cause confusion +down the road. Dracula would like to go back to a single git repository. How can Dracula undo +his last `git init` in the `moons` subdirectory? + +::::::::::::::: solution + +## Solution -- USE WITH CAUTION! + +### 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`. +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 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. +In general, deleting files and directories using `rm` from the command line cannot be reversed. +Therefore, always check your current directory using the command `pwd`. + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: keypoints + +- `git init` initializes a repository. +- Git stores all of its repository data in the `.git` directory. + +:::::::::::::::::::::::::::::::::::::::::::::::::: diff --git a/04-changes.md b/04-changes.md new file mode 100644 index 0000000000..337dea69b1 --- /dev/null +++ b/04-changes.md @@ -0,0 +1,793 @@ +--- +title: Tracking Changes +teaching: 20 +exercises: 0 +--- + +::::::::::::::::::::::::::::::::::::::: 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. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: 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? + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +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?"](https://swcarpentry.github.io/shell-novice/03-create.html#which-editor) in [The Unix Shell](https://swcarpentry.github.io/shell-novice/) 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 ..." 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 ..." 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](../learners/reference.md#commit) +(or [revision](../learners/reference.md#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][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 you want to go into more detail, add a blank line between the summary line and your additional notes. Use this additional space to explain why you made changes and/or what their impact will be. + +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 +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. + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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 ..." to update what will be committed) + (use "git checkout -- ..." 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: + +1. The first line tells us that Git is producing output similar to the Unix `diff` command + comparing the old and new versions of the file. +2. The second line tells exactly which versions of the file + Git is comparing; + `df0654a` and `315bf3a` are unique computer-generated labels for those versions. +3. The third and fourth lines once again show the name of the file being changed. +4. The remaining lines are the most interesting, they show us the actual differences + and the lines on which they occur. + In particular, + the `+` 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 ..." to update what will be committed) + (use "git checkout -- ..." 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](../learners/reference.md#changeset) +but not yet committed. + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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! + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +![](fig/git-staging-area.svg){alt='A diagram showing how "git add" registers changes in the staging area, while "git commit" moves changes from the staging area to the repository'} + +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 +Date: Thu Aug 22 10:14:07 2013 -0400 + + Discuss concerns about Mars' climate for Mummy + +commit 34961b159c27df3b475cfe4415d94a6d1fcd064d +Author: Vlad Dracula +Date: Thu Aug 22 10:07:21 2013 -0400 + + Add concerns about effects of Mars' moons on Wolfman + +commit f22b25e3233b4645dabd0d81e651fe074bd8e73b +Author: Vlad Dracula +Date: Thu Aug 22 09:51:46 2013 -0400 + + Start notes on Mars as a base +``` + +::::::::::::::::::::::::::::::::::::::::: callout + +## Word-based diffing + +Sometimes, e.g. in the case of the text documents a line-wise +diff is too coarse. That is where the `--color-words` option of +`git diff` comes in very useful as it highlights the changed +words using colors. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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 type `some_word`. + Navigate through matches pressing N. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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 +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][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 +``` + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::::: callout + +## Directories + +Two important facts you should know about directories in Git. + +1. 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. + +2. 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 + ``` + + 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`): + +![](fig/git-committing.svg){alt='A diagram showing two documents being separately staged using git add, before being combined into one commit using git commit'} + +::::::::::::::::::::::::::::::::::::::: challenge + +## Choosing a Commit Message + +Which of the following commit messages would be most appropriate for the +last commit made to `mars.txt`? + +1. "Changes" +2. "Added line 'But the Mummy will appreciate the lack of humidity' to mars.txt" +3. "Discuss effects of Mars' climate on the Mummy" + +::::::::::::::: solution + +## Solution + +Answer 1 is not descriptive enough, and the purpose of the commit is unclear; +and answer 2 is redundant to using "git diff" to see what changed in this commit; +but answer 3 is good: short, descriptive, and imperative. + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## Committing Changes to Git + +Which command(s) below would save the changes of `myfile.txt` +to my local Git repository? + +1. ```bash + $ git commit -m "my recent changes" + ``` +2. ```bash + $ git init myfile.txt + $ git commit -m "my recent changes" + ``` +3. ```bash + $ git add myfile.txt + $ git commit -m "my recent changes" + ``` +4. ```bash + $ git commit -m myfile.txt "my recent changes" + ``` + +::::::::::::::: solution + +## Solution + +1. Would only create a commit if files have already been staged. +2. Would try to create a new repository. +3. Is correct: first add the file to the staging area, then commit. +4. Would try to commit a file "my recent changes" with the message myfile.txt. + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## Committing Multiple Files + +The staging area can hold changes from any number of files +that you want to commit as a single snapshot. + +1. Add some text to `mars.txt` noting your decision + to consider Venus as a base +2. Create a new file `venus.txt` with your initial thoughts + about Venus as a base for you and your friends +3. Add changes from both files to the staging area, + and commit those changes. + +::::::::::::::: solution + +## Solution + +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 +``` + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## `bio` Repository + +- Create a new Git repository on your computer called `bio`. +- Write a three-line biography for yourself in a file called `me.txt`, + commit your changes +- Modify one line, add a fourth line +- Display the differences + between its updated state and its original state. + +::::::::::::::: solution + +## Solution + +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 +``` + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + + + +[commit-messages]: https://chris.beams.io/posts/git-commit/ +[git-references]: https://git-scm.com/book/en/v2/Git-Internals-Git-References + + +:::::::::::::::::::::::::::::::::::::::: 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. + +:::::::::::::::::::::::::::::::::::::::::::::::::: diff --git a/05-history.md b/05-history.md new file mode 100644 index 0000000000..9fc33cf5a8 --- /dev/null +++ b/05-history.md @@ -0,0 +1,623 @@ +--- +title: Exploring History +teaching: 25 +exercises: 0 +--- + +::::::::::::::::::::::::::::::::::::::: 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. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: questions + +- How can I identify old versions of files? +- How do I review my changes? +- How can I recover 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**\-d*uh*]) +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~2 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~2 mars.txt +``` + +```output +commit f22b25e3233b4645dabd0d81e651fe074bd8e73b +Author: Vlad Dracula +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 ..." to update what will be committed) + (use "git checkout -- ..." 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 ..." 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 +``` + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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 + +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`: + +![](fig/git-checkout.svg){alt='A diagram showing how git checkout HEAD~1 can be used to restore the previous version of two files'} + +So, to put it all together, +here's how Git works in cartoon form: + +![https://figshare.com/articles/How_Git_works_a_cartoon/1328266](fig/git_staging.svg){alt='A diagram showing the entire git workflow: local changes are staged using git add, applied to the local repository using git commit, and can be restored from the repository using git checkout'} + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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 -- ..." 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. + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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`? + +1. `$ git checkout HEAD` + +2. `$ git checkout HEAD data_cruncher.py` + +3. `$ git checkout HEAD~1 data_cruncher.py` + +4. `$ git checkout data_cruncher.py` + +5. Both 2 and 4 + +::::::::::::::: solution + +## Solution + +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. + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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? + +1. `________ # Look at the git history of the project to find the commit ID` + +2. Copy the ID (the first few characters of the ID, e.g. 0b1d055). + +3. `git revert [commit ID]` + +4. Type in the new commit message. + +5. Save and close + +::::::::::::::: solution + +## Solution + +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. + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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 +``` + +1. ```output + Venus is too hot to be suitable as a base + ``` +2. ```output + Venus is beautiful and full of love + ``` +3. ```output + Venus is beautiful and full of love + Venus is too hot to be suitable as a base + ``` +4. ```output + Error because you have changed venus.txt without committing the changes + ``` + +::::::::::::::: solution + +## Solution + +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. +``` + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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? + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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. + +::::::::::::::: solution + +## Solution + +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 ..." 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 ..." to update what will be committed) + (use "git checkout -- ..." 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 +``` + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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 +``` + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: keypoints + +- `git diff` displays differences between commits. +- `git checkout` recovers old versions of files. + +:::::::::::::::::::::::::::::::::::::::::::::::::: diff --git a/06-ignore.md b/06-ignore.md new file mode 100644 index 0000000000..0bdd8f5d07 --- /dev/null +++ b/06-ignore.md @@ -0,0 +1,374 @@ +--- +title: Ignoring Things +teaching: 5 +exercises: 0 +--- + +::::::::::::::::::::::::::::::::::::::: objectives + +- Configure Git to ignore specific files. +- Explain why ignoring files can be useful. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: questions + +- How can I tell Git to ignore files I don't want to track? + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +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 ..." 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 ..." 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 ..." to include in what will be committed) + + a.csv + b.csv + c.csv + results/ + +nothing to commit, working tree clean +``` + +::::::::::::::::::::::::::::::::::::::: challenge + +## Ignoring Nested Files + +Given a directory structure that looks like: + +```bash +results/data +results/plots +``` + +How would you ignore only `results/plots` and not `results/data`? + +::::::::::::::: solution + +## Solution + +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. + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## Including Specific Files + +How would you ignore all `.csv` files in your root directory except for +`final.csv`? +Hint: Find out what `!` (the exclamation point operator) does + +::::::::::::::: solution + +## Solution + +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. + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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. + +::::::::::::::: solution + +## Solution + +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 +``` + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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`. + +::::::::::::::: solution + +## Solution + +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. + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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? + +::::::::::::::: solution + +## Solution + +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. + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## The Order of Rules + +Given a `.gitignore` file with the following contents: + +```bash +*.csv +!*.csv +``` + +What will be the result? + +::::::::::::::: solution + +## Solution + +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. + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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`. + +1. Write **one** `.gitignore` entry that excludes files of the form `log_01`, `log_02`, etc. + +2. Test your "ignore pattern" by creating some dummy files of the form `log_01`, etc. + +3. You find that the file `log_01` is very important after all, add it to the tracked files without changing the `.gitignore` again. + +4. 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`. + +::::::::::::::: solution + +## Solution + +1. append either `log_*` or `log*` as a new entry in your .gitignore +2. track `log_01` using `git add -f log_01` + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: keypoints + +- The `.gitignore` file tells Git what files to ignore. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + + diff --git a/07-github.md b/07-github.md new file mode 100644 index 0000000000..41824ae72f --- /dev/null +++ b/07-github.md @@ -0,0 +1,553 @@ +--- +title: Remotes in GitHub +teaching: 45 +exercises: 0 +--- + +::::::::::::::::::::::::::::::::::::::: objectives + +- Explain what remote repositories are and why they are useful. +- Push to or pull from a remote repository. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: questions + +- How do I share my changes with others on the web? + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +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](https://github.com), [Bitbucket](https://bitbucket.org) or +[GitLab](https://gitlab.com/) to hold those main copies; we'll explore the pros +and cons of this in a [later episode](13-hosting.md). + +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](https://github.com), then click on the icon in the top right corner to +create a new repository called `planets`: + +![](fig/github-create-repo-01.png){alt='The first step in creating a repository on GitHub: clicking the "create new" button'} + +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. + +![](fig/github-create-repo-02.png){alt='The second step in creating a repository on GitHub: filling out the new repository form to provide the repository name, and specify that neither a readme nor a license should be created'} + +As soon as the repository is created, GitHub displays a page with a URL and some +information on how to configure your local repository: + +![](fig/github-create-repo-03.png){alt='The summary page displayed by GitHub after a new repository has been created. It contains instructions for configuring the new GitHub repository as a git remote'} + +This effectively does the following on GitHub's servers: + +```bash +$ mkdir planets +$ cd planets +$ git init +``` + +If you remember back to the earlier [episode](04-changes.md) where we added and +committed our earlier work on `mars.txt`, we had a diagram of the local repository +which looked like this: + +![](fig/git-staging-area.svg){alt='A diagram showing how "git add" registers changes in the staging area, while "git commit" moves changes from the staging area to the repository'} + +Now that we have two repositories, we need a diagram like this: + +![](fig/git-freshly-made-github-repo.svg) {alt='A diagram illustrating how the GitHub "planets" repository is also a git repository like our local repository, but that it is currently empty'} + +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](../learners/reference.md#remote) for the local repository. +The home page of the repository on GitHub includes the URL string we need to +identify it: + +![](fig/github-find-repo-string.png){alt='Clicking the "Copy to Clipboard" button on GitHub to obtain the repository's URL'} + +Click on the 'SSH' link to change the [protocol](../learners/reference.md#protocol) from HTTPS to SSH. + +::::::::::::::::::::::::::::::::::::::::: callout + +## HTTPS vs. SSH + +We use SSH here because, while it requires some additional configuration, it is a +security protocol widely used by many applications. The steps below describe SSH at a +minimum level for GitHub. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +![](fig/github-change-repo-string.png){alt='A screenshot showing that clicking on "SSH" will make GitHub provide the SSH URL for a repository instead of the HTTPS URL'} + +Copy that URL from the browser, go into the local `planets` repository, and run +this command: + +```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 +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. + +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. + +::::::::::::::::::::::::::::::::::::::::: callout + +## Advanced SSH + +A supplemental episode in this lesson discusses SSH and key pairs in more depth and detail. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +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. + +::::::::::::::::::::::::::::::::::::::::: callout + +## Keeping your keys secure + +You shouldn't really forget about your SSH keys, since they keep your account secure. It's good +practice to audit your secure shell keys every so often. Especially if you are using multiple +computers to access your account. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +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. + +## 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 +``` + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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 +``` + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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](https://git-scm.com/docs/gitcredentials#_requesting_credentials), 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: + +![](fig/github-repo-after-first-push.svg){alt='A diagram showing how "git push origin" will push changes from the local repository to the remote, making the remote repository an exact copy of the local repository.'} + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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. + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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? + +::::::::::::::: solution + +## Solution + +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! + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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](https://help.github.com/articles/adding-a-file-to-a-repository/). + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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](../learners/reference.md#timestamp) of the files. How does GitHub +record times, and why? + +::::::::::::::: solution + +## Solution + +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. + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## Push vs. Commit + +In this episode, we introduced the "git push" command. +How is "git push" different from "git commit"? + +::::::::::::::: solution + +## Solution + +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. + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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? + +::::::::::::::: solution + +## Solution + +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 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. + +:::::::::::::::::::::::::::::::::::::::::::::::::: diff --git a/08-collab.md b/08-collab.md new file mode 100644 index 0000000000..efaeb0eec2 --- /dev/null +++ b/08-collab.md @@ -0,0 +1,264 @@ +--- +title: Collaborating +teaching: 25 +exercises: 0 +--- + +::::::::::::::::::::::::::::::::::::::: objectives + +- Clone a remote repository. +- Collaborate by pushing to a common repository. +- Describe the basic collaborative workflow. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: questions + +- How can I use version control to collaborate with other people? + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +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. + +::::::::::::::::::::::::::::::::::::::::: callout + +## Practicing By Yourself + +If you're working through this lesson on your own, you can carry on by opening +a second terminal window. +This window will represent your partner, working on another computer. You +won't need to give anyone access on GitHub, because both 'partners' are you. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +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. + +![](fig/github-add-collaborators.png){alt='A screenshot of the GitHub Collaborators settings page, which is accessed by clicking "Settings" then "Collaborators"'} + +To accept access to the Owner's repo, the Collaborator +needs to go to [https://github.com/notifications](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. + +![](fig/github-collaboration.svg){alt='A diagram showing that "git clone" can create a copy of a remote GitHub repository, allowing a second person to create their own local repository that they can make changes to.'} + +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. + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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 change `upstream` to `fred`. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +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. + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## Switch Roles and Repeat + +Switch roles and repeat the whole process. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## Review Changes + +The Owner pushed commits to the repository without giving any information +to the Collaborator. How can the Collaborator find out what has changed with +command line? And on GitHub? + +::::::::::::::: solution + +## Solution + +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. + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## Version History, Backup, and Version Control + +Some backup software can keep a history of the versions of your files. They also +allows you to recover specific versions. How is this functionality different from version control? +What are some of the benefits of using version control, Git and GitHub? + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: keypoints + +- `git clone` copies a remote repository to create a local repository with a remote called `origin` automatically set up. + +:::::::::::::::::::::::::::::::::::::::::::::::::: diff --git a/09-conflict.md b/09-conflict.md new file mode 100644 index 0000000000..ecaad1ac62 --- /dev/null +++ b/09-conflict.md @@ -0,0 +1,533 @@ +--- +title: Conflicts +teaching: 15 +exercises: 0 +--- + +::::::::::::::::::::::::::::::::::::::: objectives + +- Explain what conflicts are and when they can occur. +- Resolve conflicts resulting from a merge. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: questions + +- What do I do when my changes conflict with someone else's? + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +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](../learners/reference.md#conflict) by giving us tools to +[resolve](../learners/reference.md#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. +``` + +![](fig/conflict.svg){alt='A diagram showing a conflict that might occur when two sets of independent changes are merged'} + +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](../learners/reference.md#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 + +::::::::::::::::::::::::::::::::::::::: challenge + +## Solving Conflicts that You Create + +Clone the repository created by your instructor. +Add a new file to it, +and modify an existing file (your instructor will tell you which one). +When asked by your instructor, +pull her changes from the repository to create a conflict, +then resolve it. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## Conflicts on Non-textual files + +What does Git do +when there is a conflict in an image or some other non-textual file +that is stored in version control? + +::::::::::::::: solution + +## Solution + +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. + + + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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 file `numbers.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! | | + +::::::::::::::: solution + +## Solution + +| 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! | | + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: keypoints + +- Conflicts occur when two or more people change the same lines of the same file. +- The version control system does not allow people to overwrite each other's changes blindly, but highlights conflicts so that they can be resolved. + +:::::::::::::::::::::::::::::::::::::::::::::::::: diff --git a/10-open.md b/10-open.md new file mode 100644 index 0000000000..1fe72edc76 --- /dev/null +++ b/10-open.md @@ -0,0 +1,161 @@ +--- +title: Open Science +teaching: 5 +exercises: 5 +--- + +::::::::::::::::::::::::::::::::::::::: objectives + +- Explain how a version control system can be leveraged as an electronic lab notebook for computational work. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: questions + +- How can version control help me make my work more open? + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +> 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](https://figshare.com/) or + [Zenodo](https://zenodo.org), possibly as soon as it's collected, + and given its own + [Digital Object Identifier](https://en.wikipedia.org/wiki/Digital_object_identifier) (DOI). + Or the data was already published and is stored in + [Dryad](https://datadryad.org/). +- 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](https://arxiv.org/) + 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](https://doi.org/10.1371/journal.pone.0000308). +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](https://link.springer.com/book/10.1007/978-3-319-00026-8). + +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. + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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](12-citation.md). + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## How Reproducible Is My Work? + +Ask one of your labmates to reproduce a result you recently obtained +using only what they can find in your papers or on the web. +Try to do the same for one of their results, +then try to do it for a result from a lab you work with. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## How to Find an Appropriate Data Repository? + +Surf the internet for a couple of minutes and check out the data repositories +mentioned above: [Figshare](https://figshare.com/), [Zenodo](https://zenodo.org), +[Dryad](https://datadryad.org/). 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](https://www.nature.com/sdata/data-policies/repositories). +Discuss with your neighbor which data repository you might want to +approach for your current project and explain why. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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](https://git-lfs.github.com) +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. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: keypoints + +- Open scientific work is more useful and more highly cited than closed. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + + diff --git a/11-licensing.md b/11-licensing.md new file mode 100644 index 0000000000..038e548d94 --- /dev/null +++ b/11-licensing.md @@ -0,0 +1,105 @@ +--- +title: Licensing +teaching: 5 +exercises: 0 +--- + +::::::::::::::::::::::::::::::::::::::: objectives + +- Explain why adding licensing information to a repository is important. +- Choose a proper license. +- Explain differences in licensing and social expectations. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: questions + +- What licensing information should I include with my work? + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +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](https://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](https://opensource.org/licenses) and [Free Software +Foundation](https://www.gnu.org/licenses/license-list.html) both +maintain lists of licenses which are good choices. + +[This article][software-licensing] 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. + +::::::::::::::::::::::::::::::::::::::: challenge + +## Can I Use Open License? + +Find out whether you are allowed to apply an open license to your software. +Can you do this unilaterally, +or do you need permission from someone in your institution? +If so, who? + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## 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? + +- [Git](https://github.com/git/git), the source-code management tool +- [CPython](https://github.com/python/cpython), the standard implementation of the Python language +- [Jupyter](https://github.com/jupyter), the project behind the web-based Python notebooks we'll be using +- [EtherPad](https://github.com/ether/etherpad-lite), a real-time collaborative editor + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +[software-licensing]: https://doi.org/10.1371/journal.pcbi.1002598 + + +:::::::::::::::::::::::::::::::::::::::: keypoints + +- The `LICENSE`, `LICENSE.md`, or `LICENSE.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. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + + diff --git a/12-citation.md b/12-citation.md new file mode 100644 index 0000000000..fa3bd229a1 --- /dev/null +++ b/12-citation.md @@ -0,0 +1,73 @@ +--- +title: Citation +teaching: 2 +exercises: 0 +--- + +::::::::::::::::::::::::::::::::::::::: objectives + +- Make your work easy to cite + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: questions + +- How can I make my work easier 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](https://github.com/swcarpentry/website/blob/gh-pages/CITATION) +states: + +```source +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](https://www.software.ac.uk/publication/how-cite-and-describe-software) and in: + +```source +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{...`](https://www.google.com/search?q=git+citation+%22%40software%7B%22) +[BibTeX](https://www.ctan.org/pkg/bibtex) entry type in case +no "umbrella" citation like a paper or book exists for the project you want to +make citable. + +:::::::::::::::::::::::::::::::::::::::: keypoints + +- Add a CITATION file to a repository to explain how you want your work cited. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + + diff --git a/13-hosting.md b/13-hosting.md new file mode 100644 index 0000000000..f17d34f554 --- /dev/null +++ b/13-hosting.md @@ -0,0 +1,111 @@ +--- +title: Hosting +teaching: 10 +exercises: 0 +--- + +::::::::::::::::::::::::::::::::::::::: objectives + +- Explain different options for hosting scientific work. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: questions + +- Where should I host my version control repositories? + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +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](https://github.com), [GitLab](https://gitlab.com), or +[BitBucket](https://bitbucket.org). +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](https://github.com/swcarpentry/) where you can find the [source for this +page](https://github.com/swcarpentry/git-novice/blob/main/episodes/13-hosting.md). Anyone with a GitHub account can suggest changes to this text. + +GitHub repositories can also be assigned DOIs, [by connecting its releases to +Zenodo](https://guides.github.com/activities/citable-code/). For example, +[`10.5281/zenodo.7908089`](https://zenodo.org/record/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. + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## Can My Work Be Public? + +Find out whether you are allowed to host your work openly in a public repository. +Can you do this unilaterally, +or do you need permission from someone in your institution? +If so, who? + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## Where Can I Share My Work? + +Does your institution have a repository or repositories that you can +use to share your papers, data and software? How do institutional repositories +differ from services like [arXiV](https://arxiv.org/), [figshare](https://figshare.com/), [GitHub](https://github.com/) or [GitLab](https://about.gitlab.com/)? + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: keypoints + +- Projects can be hosted on university servers, on personal domains, or on a public hosting service. +- Rules regarding intellectual property and storage of sensitive information apply no matter where code and data are hosted. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + + diff --git a/14-supplemental-rstudio.md b/14-supplemental-rstudio.md new file mode 100644 index 0000000000..24ced1988c --- /dev/null +++ b/14-supplemental-rstudio.md @@ -0,0 +1,190 @@ +--- +title: 'Supplemental: Using Git from RStudio' +teaching: 10 +exercises: 0 +--- + +::::::::::::::::::::::::::::::::::::::: objectives + +- Understand how to use Git from RStudio. + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::: questions + +- How can I use Git with RStudio? + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +Version control can be very useful when developing data analysis scripts. For +that reason, the popular development environment +[RStudio][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][rstudio-projects] 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: + +![](fig/RStudio_screenshot_newproject.png){alt='RStudio screenshot showing the file menu dropdown with "New Project..." selected'} + +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": + +![](fig/RStudio_screenshot_existingdirectory.png){alt='RStudio screenshot showing New Project dialog window with "Create project from existing directory" selected'} + +::::::::::::::::::::::::::::::::::::::::: callout + +## 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](https://swcarpentry.github.io/git-novice/#installing-git) +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. + +### Tell RStudio where to find GitHub + +In RStudio, go to the `Tools` menu > `Global Options` > `Git/SVN` and then +browse to the Git executable you found in the command prompt or shell. Now restart +RStudio. +Note: Even if you have Git installed, you may need +to accept the Xcode license if you are using macOS. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +Next, RStudio will ask which existing directory we want to use. Click +"Browse..." and navigate to the correct directory, then click "Create Project": + +![](fig/RStudio_screenshot_navigateexisting.png){alt='RStudio window showing the "Create Project From Existing Directory" dialog. In the dialog, the project working directory has been set to "~/Desktop/planets"'} + +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: + +![](fig/RStudio_screenshot_afterclone.png){alt='RStudio window after new project is created with large arrow pointing to vertical Git menu bar.'} + +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: + +![](fig/RStudio_screenshot_editfiles.png){alt='RStudio window demonstrating the use of the editor panel to modify the "pluto.txt" file'} + +Once we have saved our edited files, we can use RStudio to commit the changes +by clicking on "Commit..." in the Git menu: + +![](fig/RStudio_screenshot_commit.png){alt='RStudio screenshot showing the Git menu dropdown with the "Commit..." option selected'} + +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": + +![](fig/RStudio_screenshot_review.png){alt='RStudio screenshow showing the "Review Changes" dialog. The top left panel shows the list of files that can be included or excluded from the commit. The top right panel is for writing a commit message. The bottom panel shows information about the currently selected file in the top left panel.'} + +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: + +![](fig/RStudio_screenshot_history.png){alt='RStudio screenshot showing the git menu dropdown with the "History" option selected'} + +::::::::::::::::::::::::::::::::::::::::: callout + +## Are the Push/Pull Commands Grayed Out? + +Grayed out Push/Pull commands generally mean that RStudio doesn't know the +location of your remote repository (e.g. on GitHub). To fix this, open a +terminal to the repository and enter the command: `git push -u origin main`. Then restart RStudio. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +If we click on "History", we can see a graphical version of what `git log` +would tell us: + +![](fig/RStudio_screenshot_viewhistory.png){alt='RStudio screenshot showing the "Review Changes" dialog after pressing the "History" button. The top panel lists the commits in the repository, similar to git log. The bottom panel shows the changes included in the commit that has been selected in the top panel.'} + +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: + +![](fig/RStudio_screenshot_gitignore.png){alt='RStudio screenshot showing .gitignore open in the editor pane with the files .Rproj.user, .Rhistory, .RData, and \*.Rproj added to the end'} + +::::::::::::::::::::::::::::::::::::::::: callout + +## Tip: versioning disposable output + +Generally you do not want to version control disposable output (or read-only +data). You should modify the `.gitignore` file to tell Git to ignore these +files and directories. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +::::::::::::::::::::::::::::::::::::::: challenge + +## Challenge + +1. Create a new directory within your project called `graphs`. +2. Modify the `.gitignore` so that the `graphs` directory is not version controlled. + +::::::::::::::: solution + +## Solution to Challenge + +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! + +[rstudio]: https://www.rstudio.com/ +[rstudio-projects]: https://support.rstudio.com/hc/en-us/articles/200526207-Using-Projects + + +:::::::::::::::::::::::::::::::::::::::: keypoints + +- Using RStudio's Git integration allows you to version control a project over time. + +:::::::::::::::::::::::::::::::::::::::::::::::::: diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000000..f19b804953 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,13 @@ +--- +title: "Contributor Code of Conduct" +--- + +As contributors and maintainers of this project, +we pledge to follow the [The Carpentries Code of Conduct][coc]. + +Instances of abusive, harassing, or otherwise unacceptable behavior +may be reported by following our [reporting guidelines][coc-reporting]. + + +[coc-reporting]: https://docs.carpentries.org/topic_folders/policies/incident-reporting.html +[coc]: https://docs.carpentries.org/topic_folders/policies/code-of-conduct.html diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000000..7632871ff5 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,79 @@ +--- +title: "Licenses" +--- + +## Instructional Material + +All Carpentries (Software Carpentry, Data Carpentry, and Library Carpentry) +instructional material is made available under the [Creative Commons +Attribution license][cc-by-human]. The following is a human-readable summary of +(and not a substitute for) the [full legal text of the CC BY 4.0 +license][cc-by-legal]. + +You are free: + +- to **Share**---copy and redistribute the material in any medium or format +- to **Adapt**---remix, transform, and build upon the material + +for any purpose, even commercially. + +The licensor cannot revoke these freedoms as long as you follow the license +terms. + +Under the following terms: + +- **Attribution**---You must give appropriate credit (mentioning that your work + is derived from work that is Copyright (c) The Carpentries and, where + practical, linking to ), provide a [link to the + license][cc-by-human], and indicate if changes were made. You may do so in + any reasonable manner, but not in any way that suggests the licensor endorses + you or your use. + +- **No additional restrictions**---You may not apply legal terms or + technological measures that legally restrict others from doing anything the + license permits. With the understanding that: + +Notices: + +* You do not have to comply with the license for elements of the material in + the public domain or where your use is permitted by an applicable exception + or limitation. +* No warranties are given. The license may not give you all of the permissions + necessary for your intended use. For example, other rights such as publicity, + privacy, or moral rights may limit how you use the material. + +## Software + +Except where otherwise noted, the example programs and other software provided +by The Carpentries are made available under the [OSI][osi]-approved [MIT +license][mit-license]. + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +## Trademark + +"The Carpentries", "Software Carpentry", "Data Carpentry", and "Library +Carpentry" and their respective logos are registered trademarks of [Community +Initiatives][ci]. + +[cc-by-human]: https://creativecommons.org/licenses/by/4.0/ +[cc-by-legal]: https://creativecommons.org/licenses/by/4.0/legalcode +[mit-license]: https://opensource.org/licenses/mit-license.html +[ci]: https://communityin.org/ +[osi]: https://opensource.org diff --git a/config.yaml b/config.yaml new file mode 100644 index 0000000000..c3626edcf3 --- /dev/null +++ b/config.yaml @@ -0,0 +1,94 @@ +#------------------------------------------------------------ +# Values for this lesson. +#------------------------------------------------------------ + +# Which carpentry is this (swc, dc, lc, or cp)? +# swc: Software Carpentry +# dc: Data Carpentry +# lc: Library Carpentry +# cp: Carpentries (to use for instructor training for instance) +# incubator: The Carpentries Incubator +carpentry: 'swc' + +# Overall title for pages. +title: 'Version Control with Git' + +# Date the lesson was created (YYYY-MM-DD, this is empty by default) +created: '2014-12-04' + +# Comma-separated list of keywords for the lesson +keywords: 'software, data, lesson, The Carpentries' + +# Life cycle stage of the lesson +# possible values: pre-alpha, alpha, beta, stable +life_cycle: 'stable' + +# License of the lesson materials (recommended CC-BY 4.0) +license: 'CC-BY 4.0' + +# Link to the source repository for this lesson +source: 'https://github.com/swcarpentry/git-novice' + +# Default branch of your lesson +branch: 'main' + +# Who to contact if there are any issues +contact: 'team@carpentries.org' + +# Navigation ------------------------------------------------ +# +# Use the following menu items to specify the order of +# individual pages in each dropdown section. Leave blank to +# include all pages in the folder. +# +# Example ------------- +# +# episodes: +# - introduction.md +# - first-steps.md +# +# learners: +# - setup.md +# +# instructors: +# - instructor-notes.md +# +# profiles: +# - one-learner.md +# - another-learner.md + +# Order of episodes in your lesson +episodes: +- 01-basics.md +- 02-setup.md +- 03-create.md +- 04-changes.md +- 05-history.md +- 06-ignore.md +- 07-github.md +- 08-collab.md +- 09-conflict.md +- 10-open.md +- 11-licensing.md +- 12-citation.md +- 13-hosting.md +- 14-supplemental-rstudio.md + +# Information for Learners +learners: + +# Information for Instructors +instructors: + +# Learner Profiles +profiles: + +# Customisation --------------------------------------------- +# +# This space below is where custom yaml items (e.g. pinning +# sandpaper and varnish versions) should live + + +url: 'https://swcarpentry.github.io/git-novice' +analytics: carpentries +lang: en diff --git a/discuss.md b/discuss.md new file mode 100644 index 0000000000..def35b113a --- /dev/null +++ b/discuss.md @@ -0,0 +1,476 @@ +--- +title: Discussion +--- + +## Frequently Asked Questions + +People often have questions about Git beyond the scope of the core material. +Students who have completed the rest of the lessons might find value in looking through the following topics. + +Note that since this material isn't essential for basic Git usage, it won't be covered by the instructor. + +## More Advanced Git Configuration + +In [Setting Up Git](../episodes/02-setup.md), +we used `git config --global` to set some default options for Git. +It turns out that these configuration options get stored in your home directory +in a plain text file called `.gitconfig`. + +```bash +$ cat ~/.gitconfig +``` + +```output +[user] + name = Vlad Dracula + email = vlad@tran.sylvan.ia +[color] + ui = true +[core] + editor = nano +``` + +This file can be opened in your preferred text editor. +(Note that it is recommended to continue using the `git config` command, +as this helps avoid introducing syntax errors.) + +Eventually, you will want to start customizing Git's behaviour. +This can be done by adding more entries to your `.gitconfig`. +The available options are described in the manual: + +```bash +$ git config --help +``` + +In particular, you might find it useful to add aliases. +These are like shortcuts for longer Git commands. +For example, if you get sick of typing `git checkout` all the time, +you could run the command: + +```bash +$ git config --global alias.co checkout +``` + +Now if we return to the example from [Exploring History](../episodes/05-history.md) where we ran: + +```bash +$ git checkout f22b25e mars.txt +``` + +we could now instead type: + +```bash +$ git co f22b25e mars.txt +``` + +## Styling Git's Log + +A good target for customization is output from the log. +The default log is quite verbose but gives no graphical hints +such as information about which commits were done locally +and which were pulled from remotes. + +You can use `git log --help` and `git config --help` to look for different ways to change +the log output. +Try the following commands and see what effect they have: + +```bash +$ git config --global alias.lg "log --graph" +$ git config --global log.abbrevCommit true +$ git config --global format.pretty oneline +$ git lg +``` + +If you don't like the effects, +you can undo them with: + +```bash +$ git config --global --unset alias.lg +$ git config --global --unset log.abbrevCommit +$ git config --global --unset format.pretty +``` + +::::::::::::::::::::::::::::::::::::::::: callout + +## Undoing Git Configuration Changes + +You can use the `--unset` flag to delete unwanted options from `.gitconfig`. +Another way to roll back changes is to store your `.gitconfig` using Git. + +For hints on what you might want to configure, +go to GitHub and search for "gitconfig". +You will find hundreds of repositories in which people have stored +their own Git configuration files. +Sort them by the number of stars and have a look at the top few. +If you find some you like, +please check that they're covered by an open source license before you clone them. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + +## Non-text Files + +Recall when we discussed [Conflicts](../episodes/09-conflict.md) +there was a challenge that asked, +"What does Git do +when there is a conflict in an image or some other non-textual file +that is stored in version control?" + +We will now revisit this in more detail. + +Many people want to version control non-text files, such as images, PDFs and Microsoft Office or LibreOffice documents. +It is true that Git can handle these filetypes (which fall under the banner of "binary" file types). +However, just because it *can* be done doesn't mean it *should* be done. + +Much of Git's magic comes from being able to do line-by-line comparisons ("diffs") between files. +This is generally easy for programming source code and marked up text. +For non-text files, a diff can usually only detect that the files have changed +but can't say how or where. + +This has various impacts on Git's performance and will make it difficult to +compare different versions of your project. + +For a basic example to show the difference it makes, +we're going to go see what would have happened if Dracula had tried +using outputs from a word processor instead of plain text. + +Create a new directory and go into it: + +```bash +$ mkdir planets-nontext +$ cd planets-nontext +``` + +Use a program such as Microsoft Word or LibreOffice Writer to create a new document. +Enter the same text that we began with before: + +```output +Cold and dry, but everything is my favorite color +``` + +Save the document into the `planets-nontext` directory with the name of `mars.doc`. +Back in the terminal, run the usual commands for setting up a new Git repository: + +```bash +$ git init +$ git add mars.doc +$ git commit -m "Starting to think about Mars" +``` + +Then make the same changes to `mars.doc` that we (or Vlad) previously made to `mars.txt`. + +```output +Cold and dry, but everything is my favorite color +The two moons may be a problem for Wolfman +``` + +Save and close the word processor. +Now see what Git thinks of your changes: + +```bash +$ git diff +``` + +```output +diff --git a/mars.doc b/mars.doc +index 53a66fd..6e988e9 100644 +Binary files a/mars.doc and b/mars.doc differ +``` + +Compare this to the earlier `git diff` obtained when using text files: + +```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 +``` + +Notice how plain text files give a much more informative diff. +You can see exactly which lines changed and what the changes were. + +An uninformative `git diff` is not the only consequence of using Git on binary files. +However, most of the other problems boil down to whether or not a good diff is possible. + +This isn't to say you should *never* use Git on binary files. +A rule of thumb is that it's OK if the binary file won't change very often, +and if it does change, you don't care about merging in small differences between versions. + +We've already seen how a word processed report will fail this test. +An example that passes the test is a logo for your organization or project. +Even though a logo will be stored in a binary format such as `jpg` or `png`, +you can expect it will remain fairly static through the lifetime of your repository. +On the rare occasion that branding does change, +you will probably just want to replace the logo completely rather than merge little differences in. + +## Removing a File + +Adding and modifying files are not the only actions one might take +when working on a project. It might be required to remove a file +from the repository. + +Create a new file for the planet Nibiru: + +```bash +$ echo "This is another name for fake planet X" > nibiru.txt +``` + +Now add to the repository like you have learned earlier: + +```bash +$ git add nibiru.txt +$ git commit -m 'adding info on nibiru' +$ git status +``` + +```output +On branch main +nothing to commit, working tree clean +``` + +Nibiru is not a real planet. That was a silly idea. Let us remove +it from the disk and let Git know about it: + +```bash +$ git rm nibiru.txt +$ git status +``` + +```output +On branch main +Changes to be committed: + (use "git reset HEAD ..." to unstage) + + deleted: nibiru.txt + +``` + +The change has been staged. Now commit the removal, and remove the +file from the repository itself. Note that the file will be removed +in the new commit. The previous commit will still +have the file, if you were to retrieve that specific commit. + +```bash +$ git commit -m 'Removing info on Nibiru. It is not a real planet!' +``` + +## Removing a File with Unix + +Sometimes we might forget to remove the file through Git. If you removed the +file with Unix `rm` instead of using `git rm`, no worries, +Git is smart enough to notice the missing file. Let us recreate the file and +commit it again. + +```bash +$ echo "This is another name for fake planet X" > nibiru.txt +$ git add nibiru.txt +$ git commit -m 'adding nibiru again' +``` + +Now we remove the file with Unix `rm`: + +```bash +$ rm nibiru.txt +$ git status +``` + +```output +On branch main +Changes not staged for commit: + (use "git add/rm ..." to update what will be committed) + (use "git checkout -- ..." to discard changes in working directory) + + deleted: nibiru.txt + +no changes added to commit (use "git add" and/or "git commit -a") +``` + +See how Git has noticed that the file `nibiru.txt` has been removed +from the disk. The next step is to "stage" the removal of the file +from the repository. This is done with the command `git rm` just as +before. + +```bash +$ git rm nibiru.txt +$ git status +``` + +```output +On branch main +Changes to be committed: + (use "git reset HEAD ..." to unstage) + + deleted: nibiru.txt + +``` + +The change that was made in Unix has now been staged and needs to be +committed. + +```bash +$ git commit -m 'Removing info on Nibiru, again!' +``` + +## Renaming a File + +Another common change when working on a project is to rename a file. + +Create a file for the planet Krypton: + +```bash +$ echo "Superman's home planet" > krypton.txt +``` + +Add it to the repository: + +```bash +$ git add krypton.txt +$ git commit -m 'Adding planet Krypton' +``` + +We all know that Superman moved to Earth. Not that he had much +choice. Now his home planet is Earth. + +Rename the file `krypton.txt` to `earth.txt` with Git: + +```bash +$ git mv krypton.txt earth.txt +$ git status +``` + +```output +On branch main +Changes to be committed: + (use "git reset HEAD ..." to unstage) + + renamed: krypton.txt -> earth.txt +``` + +The final step is commit our change to the repository: + +```bash +$ git commit -m 'Superman's home is now Earth' +``` + +## Renaming a File with Unix + +If you forgot to use Git and you used Unix `mv` instead +of `git mv`, you will have a touch more work to do but Git will +be able to deal with it. Let's try again renaming the file, +this time with Unix `mv`. First, we need to recreate the +`krypton.txt` file: + +```bash +$ echo "Superman's home planet" > krypton.txt +$ git add krypton.txt +$ git commit -m 'Adding planet Krypton again.' +``` + +Let us rename the file and see what Git can figured out by itself: + +```bash +$ mv krypton.txt earth.txt +$ git status +``` + +```output +On branch main +Changes not staged for commit: + (use "git add/rm ..." to update what will be committed) + (use "git checkout -- ..." to discard changes in working directory) + + deleted: krypton.txt + +Untracked files: + (use "git add ..." to include in what will be committed) + + earth.txt + +no changes added to commit (use "git add" and/or "git commit -a") +``` + +Git has noticed that the file `krypton.txt` has disappeared from the +file system and a new file `earth.txt` has showed up. + +Add those changes to the staging area: + +```bash +$ git add krypton.txt earth.txt +$ git status +``` + +```output +On branch main +Changes to be committed: + (use "git reset HEAD ..." to unstage) + + renamed: krypton.txt -> earth.txt + +``` + +Notice how Git has now figured out that the `krypton.txt` has not +disappeared - it has simply been renamed. + +The final step, as before, is to commit our change to the repository: + +```bash +$ git commit -m 'Superman's home is Earth, told you before.' +``` + +## Further .gitignore concepts + +For additional documentation on .gitignore, please reference +[the official git documentation](https://git-scm.com/docs/gitignore). + +In the ignore exercise, learners were presented with two variations of ignoring +nested files. Depending on the organization of your repository, one may suit +your needs over another. Keep in mind that the way that Git travels along +directory paths can be confusing. + +Sometimes the `**` pattern comes in handy, too, which matches multiple +directory levels. E.g. `**/results/plots/*` would make git ignore the +`results/plots` directory in any root directory. + +::::::::::::::::::::::::::::::::::::::: challenge + +## Ignoring Nested Files: Challenge Problem + +Given a directory structure that looks like: + +```bash +results/data +results/plots +results/run001.log +results/run002.log +``` + +And a .gitignore that looks like: + +```output +*.csv +``` + +How would you track all of the contents of `results/data/`, including `*.csv` +files, but ignore the rest of `results/`? + +::::::::::::::: solution + +## Solution + +To do this, your .gitignore would look like this: + +```output +*.csv # ignore the .csv files +results/* # ignore the files in the results directory +!results/data/ # do not ignore the files in results/data +!results/data/* # do not ignore the .csv files in reults/data +``` + +::::::::::::::::::::::::: + +:::::::::::::::::::::::::::::::::::::::::::::::::: + + diff --git a/fig/RStudio_screenshot_afterclone.png b/fig/RStudio_screenshot_afterclone.png new file mode 100644 index 0000000000..268c188c42 Binary files /dev/null and b/fig/RStudio_screenshot_afterclone.png differ diff --git a/fig/RStudio_screenshot_commit.png b/fig/RStudio_screenshot_commit.png new file mode 100644 index 0000000000..66aeeab724 Binary files /dev/null and b/fig/RStudio_screenshot_commit.png differ diff --git a/fig/RStudio_screenshot_editfiles.png b/fig/RStudio_screenshot_editfiles.png new file mode 100644 index 0000000000..251aed4bdf Binary files /dev/null and b/fig/RStudio_screenshot_editfiles.png differ diff --git a/fig/RStudio_screenshot_existingdirectory.png b/fig/RStudio_screenshot_existingdirectory.png new file mode 100644 index 0000000000..27658eee10 Binary files /dev/null and b/fig/RStudio_screenshot_existingdirectory.png differ diff --git a/fig/RStudio_screenshot_gitignore.png b/fig/RStudio_screenshot_gitignore.png new file mode 100644 index 0000000000..225e101784 Binary files /dev/null and b/fig/RStudio_screenshot_gitignore.png differ diff --git a/fig/RStudio_screenshot_history.png b/fig/RStudio_screenshot_history.png new file mode 100644 index 0000000000..52600748e4 Binary files /dev/null and b/fig/RStudio_screenshot_history.png differ diff --git a/fig/RStudio_screenshot_navigateexisting.png b/fig/RStudio_screenshot_navigateexisting.png new file mode 100644 index 0000000000..ef8fcf8c1b Binary files /dev/null and b/fig/RStudio_screenshot_navigateexisting.png differ diff --git a/fig/RStudio_screenshot_newproject.png b/fig/RStudio_screenshot_newproject.png new file mode 100644 index 0000000000..a4f7f79f45 Binary files /dev/null and b/fig/RStudio_screenshot_newproject.png differ diff --git a/fig/RStudio_screenshot_review.png b/fig/RStudio_screenshot_review.png new file mode 100644 index 0000000000..3854b8623a Binary files /dev/null and b/fig/RStudio_screenshot_review.png differ diff --git a/fig/RStudio_screenshot_viewhistory.png b/fig/RStudio_screenshot_viewhistory.png new file mode 100644 index 0000000000..4917409351 Binary files /dev/null and b/fig/RStudio_screenshot_viewhistory.png differ diff --git a/fig/conflict.svg b/fig/conflict.svg new file mode 100644 index 0000000000..ce24496a2c --- /dev/null +++ b/fig/conflict.svg @@ -0,0 +1,309 @@ + + + +image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/fig/git-checkout.svg b/fig/git-checkout.svg new file mode 100644 index 0000000000..fe5599d4f2 --- /dev/null +++ b/fig/git-checkout.svg @@ -0,0 +1,111 @@ + + + + + + + + .git + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + FILE1.txt + + + + + + + + + + + + + + FILE2.txt + + + HEAD + + HEAD~1 + + HEAD~2 + + 892134f + + f22b25e + + 3a54f76 + + + + + + + + + git checkout HEAD~1or git checkout f22b25e + + + repository + + diff --git a/fig/git-committing.svg b/fig/git-committing.svg new file mode 100644 index 0000000000..71b9dcae0c --- /dev/null +++ b/fig/git-committing.svg @@ -0,0 +1,436 @@ + + + +image/svg+xml.git +FILE1.txt +FILE2.txt +git commit +staging area +repository +git add FILE2.txt +git add FILE1.txt + \ No newline at end of file diff --git a/fig/git-freshly-made-github-repo.svg b/fig/git-freshly-made-github-repo.svg new file mode 100644 index 0000000000..2d70ffd175 --- /dev/null +++ b/fig/git-freshly-made-github-repo.svg @@ -0,0 +1,315 @@ + + + +image/svg+xml.git +https://github.com/vlad/planets.git +.git +~/vlad/planets +git add +git commit +staging area +repository + \ No newline at end of file diff --git a/fig/git-staging-area.svg b/fig/git-staging-area.svg new file mode 100644 index 0000000000..c74c2987ee --- /dev/null +++ b/fig/git-staging-area.svg @@ -0,0 +1,93 @@ + + + + + + + + .git + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + git add + + + + + + git commit + + staging area + + repository + + diff --git a/fig/git_staging.svg b/fig/git_staging.svg new file mode 100644 index 0000000000..dd59510bd8 --- /dev/null +++ b/fig/git_staging.svg @@ -0,0 +1,675 @@ + + + +image/svg+xmla2129cb + +892134f + +59e230a + +3a54f76 + +43fe423 + + + + branch + +main + +staging area + +git add file2.txt + +git add file1.txt + +HEADHEAD~1HEAD~2 + +git commit + +git checkout HEAD file1.txt + + + diff --git a/fig/github-add-collaborators.png b/fig/github-add-collaborators.png new file mode 100644 index 0000000000..7833454dfa Binary files /dev/null and b/fig/github-add-collaborators.png differ diff --git a/fig/github-change-repo-string.png b/fig/github-change-repo-string.png new file mode 100644 index 0000000000..7ffe1bfda6 Binary files /dev/null and b/fig/github-change-repo-string.png differ diff --git a/fig/github-collaboration.svg b/fig/github-collaboration.svg new file mode 100644 index 0000000000..2e79e17509 --- /dev/null +++ b/fig/github-collaboration.svg @@ -0,0 +1,767 @@ + + + +image/svg+xml +.gitorigin https://github.com/vlad/planets.git +~/vlad/planets +git add +git commit +staging area +repository +.git +https://github.com/vlad/planets.git +repository +git clone +.gitorigin https://github.com/vlad/planets.git +~/wolfman/planets +git add +git commit +staging area +repository + \ No newline at end of file diff --git a/fig/github-create-repo-01.png b/fig/github-create-repo-01.png new file mode 100644 index 0000000000..6dc6bf2195 Binary files /dev/null and b/fig/github-create-repo-01.png differ diff --git a/fig/github-create-repo-02.png b/fig/github-create-repo-02.png new file mode 100644 index 0000000000..5981881cda Binary files /dev/null and b/fig/github-create-repo-02.png differ diff --git a/fig/github-create-repo-03.png b/fig/github-create-repo-03.png new file mode 100644 index 0000000000..ebce87d5e6 Binary files /dev/null and b/fig/github-create-repo-03.png differ diff --git a/fig/github-find-repo-string.png b/fig/github-find-repo-string.png new file mode 100644 index 0000000000..97d339bd72 Binary files /dev/null and b/fig/github-find-repo-string.png differ diff --git a/fig/github-repo-after-first-push.svg b/fig/github-repo-after-first-push.svg new file mode 100644 index 0000000000..7003395416 --- /dev/null +++ b/fig/github-repo-after-first-push.svg @@ -0,0 +1,483 @@ + + + +image/svg+xml +.gitorigin https://github.com/vlad/planets.git +~/vlad/planets +git add +git commit +staging area +repository +.git +https://github.com/vlad/planets.git +repository +git push origin + \ No newline at end of file diff --git a/fig/merge.svg b/fig/merge.svg new file mode 100644 index 0000000000..bc1378cbab --- /dev/null +++ b/fig/merge.svg @@ -0,0 +1,122 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/fig/motivatingexample.png b/fig/motivatingexample.png new file mode 100644 index 0000000000..e9320a90ee Binary files /dev/null and b/fig/motivatingexample.png differ diff --git a/fig/phd101212s.png b/fig/phd101212s.png new file mode 100644 index 0000000000..c47c428bde Binary files /dev/null and b/fig/phd101212s.png differ diff --git a/fig/play-changes.svg b/fig/play-changes.svg new file mode 100644 index 0000000000..d1a22e79bf --- /dev/null +++ b/fig/play-changes.svg @@ -0,0 +1,175 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/fig/versions.svg b/fig/versions.svg new file mode 100644 index 0000000000..96e8cab171 --- /dev/null +++ b/fig/versions.svg @@ -0,0 +1,247 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/index.md b/index.md new file mode 100644 index 0000000000..cb4d9c0609 --- /dev/null +++ b/index.md @@ -0,0 +1,58 @@ +--- +permalink: index.html +site: sandpaper::sandpaper_site +--- + +Wolfman and Dracula have been hired by Universal Missions (a space +services spinoff from Euphoric State University) to investigate if it +is possible to send their next planetary lander to Mars. They want to +be able to work on the plans at the same time, but they have run into +problems doing this in the past. If they take turns, each one will +spend a lot of time waiting for the other to finish, but if they work +on their own copies and email changes back and forth things will be +lost, overwritten, or duplicated. + +A colleague suggests using [version control](learners/reference.md#version-control) to +manage their work. Version control is better than mailing files back and forth: + +- Nothing that is committed to version control is ever lost, unless + you work really, really hard at losing it. Since all old versions of + files are saved, it's always possible to go back in time to see + exactly who wrote what on a particular day, or what version of a + program was used to generate a particular set of results. + +- As we have this record of who made what changes when, we know who to ask + if we have questions later on, and, if needed, revert to a previous + version, much like the "undo" feature in an editor. + +- When several people collaborate in the same project, it's possible to + accidentally overlook or overwrite someone's changes. The version control + system automatically notifies users whenever there's a conflict between one + person's work and another's. + +Teams are not the only ones to benefit from version control: lone +researchers can benefit immensely. Keeping a record of what was +changed, when, and why is extremely useful for all researchers if they +ever need to come back to the project later on (e.g., a year later, +when memory has faded). + +Version control is the lab notebook of the digital world: it's what +professionals use to keep track of what they've done and to +collaborate with other people. Every large software development +project relies on it, and most programmers use it for their small jobs +as well. And it isn't just for software: books, +papers, small data sets, and anything that changes over time or needs +to be shared can and should be stored in a version control system. + +:::::::::::::::::::::::::::::::::::::::::: prereq + +## Prerequisites + +In this lesson we use Git from the Unix Shell. +Some previous experience with the shell is expected, +*but isn't mandatory*. + + +:::::::::::::::::::::::::::::::::::::::::::::::::: + + diff --git a/instructor-notes.md b/instructor-notes.md new file mode 100644 index 0000000000..4d8812e2f2 --- /dev/null +++ b/instructor-notes.md @@ -0,0 +1,317 @@ +--- +title: Instructor Notes +--- + +Using a software tool to handle the versions of your project files +lets you focus on the more interesting/innovative aspects of your project. + +- Version control's advantages + - It's easy to set up + - Every copy of a Git repository is a full backup of a project and its history + - A few easy-to-remember commands are all you need for most day-to-day version control tasks + - The [GitHub][github] hosting service provides a web-based collaboration service +- Two main concepts + - *commit*: a recorded set of changes in your project's files + - *repository*: the history of all your project's commits +- Why use GitHub? + - No need for a server: easy to set up + - GitHub's strong community: your colleagues are probably already there + +## Overall + +Version control might be the most important topic we teach, but Git is +definitely the most complicated tool. However, GitHub presently dominates the +open software repository landscape, so the time and effort required to teach +fundamental Git is justified and worthwhile. + +Because of this complexity, we don't teach novice learners about many +interesting topics, such as branching, hashes, and commit objects. + +Instead we try to convince them that version control is useful for researchers +working in teams or not, because it is + +- a better way to "undo" changes, +- a better way to collaborate than mailing files back and forth, and +- a better way to share your code and other scientific work with the world. + +## Teaching Notes + +- You can "split" your shell so that recent commands remain in view using [this](https://github.com/rgaiacs/swc-shell-split-window) script. + +- Make sure the network is working *before* starting this lesson. + +- Drawings are particularly useful in this lesson: if you have a whiteboard, + [use it][drawings]! + +- Version control is usually not the first subject in a workshop, + so get learners to create a GitHub account after the session before. + Remind learners that the username and email they use for GitHub (and setup + during Git configuration) will be viewable to the public by default. + However, there are many reasons why a learner may not want their personal + information viewable, and GitHub has [resources for keeping an email address + private][github-privacy]. + +- If some learners are using Windows, there will inevitably be issues + merging files with different line endings. (Even if everyone's on + some flavor of Unix, different editors may or may not add a + newline to the last line of a file.) Take a moment to explain + these issues, since learners will almost certainly trip over them + again. If learners are running into line ending problems, GitHub + has a [page][github-line-endings] that helps with troubleshooting. + Specifically, the [section on refreshing a repository][github-line-endings-refresh] + may be helpful if learners need to change the `core.autocrlf` setting + after already having made one or more commits. + +- We don't use a Git GUI in these notes because we haven't found one that + installs easily and runs reliably on the three major operating systems, and + because we want learners to understand what commands are being run. That + said, instructors should demo a GUI on their desktop at some point during + this lesson and point learners at [this page][github-gui]. + +- Instructors should show learners graphical diff/merge tools like + [DiffMerge][diffmerge]. + +- When appropriate, explain that we teach Git rather than CVS, Subversion, or + Mercurial primarily because of GitHub's growing popularity: CVS and + Subversion are now seen as legacy systems, and Mercurial isn't nearly as + widely used in the sciences right now. + +- Further resources: + + - [git-it] is a self-paced command-line Git demo, + with [git-it-electron] its GitHub Desktop successor. + - [Code School][code-school] has a free interactive course, [Try Git][try-git]. + - for instructors, [the Git parable][git-parable] is useful background reading + +## [Automated Version Control](../episodes/01-basics.md) + +- Ask, "Who uses 'undo' in their editor?" All say "Me". 'Undo' is the simplest + form of version control. + +- Give learners a five-minute overview of what version control does for them + before diving into the watch-and-do practicals. Most of them will have + tried to co-author papers by emailing files back and forth, or will have + biked into the office only to realize that the USB key with last night's + work is still on the kitchen table. Instructors can also make jokes about + directories with names like "final version", "final version revised", + "final version with reviewer three's corrections", "really final version", + and, "come on this really has to be the last version" to motivate version + control as a better way to collaborate and as a better way to back work up. + +## [Setting Up Git](../episodes/02-setup.md) + +- We suggest instructors and students use `nano` as the text editor for this + lessons because + + - it runs in all three major operating systems, + - it runs inside the shell (switching windows can be confusing to students), and + - it has shortcut help at the bottom of the window. + + Please point out to students during setup that they can and should use + another text editor if they're already familiar with it. + +- When setting up Git, be very clear what learners have to enter: it is + common for them to edit the instructor's details (e.g. email). Check at + the end using `git config --list`. + +- When setting up the default branch name, if learners have a Git version + older than 2.28, the default branch name can be changed for the lesson + using `git branch -M main` if there are currently commits in the repository, + or `git checkout -b main` if there are no commits/the repository is completely empty. + +## [Creating a Repository](../episodes/03-create.md) + +- When you do `git status`, Mac users may see a `.DS_Store` file showing as + untracked. This a file that Mac OS creates in each directory. + +- The challenge "Places to create repositories" tries to reinforce the idea + that the `.git` folder contains the whole Git repo and deleting this folder + undoes a `git init`. It also gives the learner the way to fix the common + mistake of putting unwanted folders (like `Desktop`) under version control. + + Instead of removing the `.git` folder directly, you can choose to move it + first to a safer directory and remove it from there: + + ```bash + $ mv .git temp_git + $ rm -rf temp_git + ``` + + The challenge suggests that it is a bad idea to create a Git repo inside another repo. + For more discussion on this topic, please see [this issue][repos-in-repos]. + +## [Tracking Changes](../episodes/04-changes.md) + +- It's important that learners do a full commit cycle by themselves (make + changes, `git diff`, `git add`, and `git commit`). The "`bio` repository" + challenge does that. + +- This is a good moment to show a diff with a graphical diff tool. If you + skip it because you're short on time, show it once in GitHub. + +- One thing may cause confusion is recovering old versions. If, instead of + doing `$ git checkout f22b25e mars.txt`, someone does `$ git checkout f22b25e`, they wind up in the "detached HEAD" state and confusion abounds. + It's then possible to keep on committing, but things like `git push origin main` a bit later will not give easily comprehensible results. It also + makes it look like commits can be lost. To "re-attach" HEAD, use + `git checkout main`. + +- This is a good moment to show a log within a Git GUI. If you skip it + because you're short on time, show it once in GitHub. + +## [Ignoring Things](../episodes/06-ignore.md) + +Just remember that you can use wildcards and regular expressions to ignore a +particular set of files in `.gitignore`. + +## [Remotes in GitHub](../episodes/07-github.md) + +- Make it clear that Git and GitHub are not the same thing: Git is an open + source version control tool, GitHub is a company that hosts Git + repositories in the web and provides a web interface to interact with repos + they host. + +- It is very useful to draw a diagram showing the different repositories + involved. + +- When pushing to a remote, the output from Git can vary slightly depending on + what leaners execute. The lesson displays the output from git if a learner + executes `git push origin main`. However, some learners might use syntax + suggested by GitHub for pushing to a remote with an existing repository, + which is `git push -u origin main`. Learners using syntax from GitHub, + `git push -u origin main`, will have slightly different output, including + the line `Branch main set up to track remote branch main from origin by rebasing.` + +## [Collaborating](../episodes/08-collab.md) + +- Decide in advance whether all the learners will work in one shared + repository, or whether they will work in pairs (or other small groups) in + separate repositories. The former is easier to set up; the latter runs + more smoothly. + +- Role playing between two instructors can be effective when teaching the + collaboration and conflict sections of the lesson. One instructor can play + the role of the repository owner, while the second instructor can play the + role of the collaborator. If it is possible, try to use two projectors so + that the computer screens of both instructors can be seen. This makes for + a very clear illustration to the students as to who does what. + +- It is also effective to pair up students during this lesson and assign one + member of the pair to take the role of the owner and the other the role of + the collaborator. In this setup, challenges can include asking the + collaborator to make a change, commit it, and push the change to the remote + repository so that the owner can then retrieve it, and vice-versa. The + role playing between the instructors can get a bit "dramatic" in the + conflicts part of the lesson if the instructors want to inject some humor + into the room. + +- If you don't have two projectors, have two instructors at the front of the + room. Each instructor does their piece of the collaboration demonstration + on their own computer and then passes the projector cord back and forth + with the other instructor when it's time for them to do the other part of + the collaborative workflow. It takes less than 10 seconds for each + switchover, so it doesn't interrupt the flow of the lesson. + And of course it helps to give each of the instructors a different-colored + hat, or put different-colored sticky notes on their foreheads. + +- If you're the only instructor, the best way to create is clone the two + repos in your Desktop, but under different names, e.g., pretend one is your + computer at work: + + ```bash + $ git clone https://github.com/vlad/planets.git planets-at-work + ``` + +- It's very common that learners mistype the remote alias or the remote URL + when adding a remote, so they cannot `push`. You can diagnose this with + `git remote -v` and checking carefully for typos. + + - To fix a wrong alias, you can do `git remote rename `. + - To fix a wrong URL, you can do `git remote set-url `. + +- Before cloning the repo, be sure that nobody is inside another repo. The + best way to achieve this is moving to the `Desktop` before cloning: `cd && cd Desktop`. + +- If both repos are in the `Desktop`, have them to clone their collaborator + repo under a given directory using a second argument: + + ```bash + $ git clone https://github.com/vlad/planets.git vlad-planet + ``` + +- The most common mistake is that learners `push` before `pull`ing. If they + `pull` afterward, they may get a conflict. + +- Conflicts, sometimes weird, will start to arise. Stay tight: conflicts are + next. + +- Learners may have slightly different output from `git push` and `git pull` + depending on the version of git, and if upstream (`-u`) is used. + +## [Conflicts](../episodes/09-conflict.md) + +- Expect the learners to make mistakes. Expect *yourself* to make mistakes. + This happens because it is late in the lesson and everyone is tired. + +- If you're the only instructor, the best way to create a conflict is: + + - Clone your repo in a different directory, pretending is your computer at + work: `git clone https://github.com/vlad/planets.git planets-at-work`. + - At the office, you make a change, commit and push. + - At your laptop repo, you (forget to pull and) make a change, commit and + try to push. + - `git pull` now and show the conflict. + +- Learners usually forget to `git add` the file after fixing the conflict and + just (try to) commit. You can diagnose this with `git status`. + +- Remember that you can discard one of the two parents of the merge: + + - discard the remote file, `git checkout --ours conflicted_file.txt` + - discard the local file, `git checkout --theirs conflicted_file.txt` + + You still have to `git add` and `git commit` after this. This is + particularly useful when working with binary files. + +- Keep in mind that depending on the Git version used, the outputs for + `git push` and `git pull` can vary slightly. + +## [Open Science](../episodes/10-open.md) + +## [Licensing](../episodes/11-licensing.md) + +We teach about licensing because questions about who owns what, or can use +what, arise naturally once we start talking about using public services like +GitHub to store files. Also, the discussion gives learners a chance to catch +their breath after what is often a frustrating couple of hours. + +The Creative Commons family of licenses is recommended for many types of +works (including software documentation and images used in software) but not +software itself. Creative Commons [recommends][cc-faq-software] a +software-specific license instead. + +## [Citation](../episodes/12-citation.md) + +## [Hosting](../episodes/13-hosting.md) + +A common concern for learners is having their work publicly available on +GitHub. While we encourage open science, sometimes private repos are the +only choice. It's always interesting to mention the options to have +web-hosted private repositories. + +[github]: https://github.com/ +[drawings]: https://marklodato.github.io/visual-git-guide/index-en.html +[github-privacy]: https://help.github.com/articles/keeping-your-email-address-private/ +[github-line-endings]: https://docs.github.com/en/github/using-git/configuring-git-to-handle-line-endings +[github-line-endings-refresh]: https://docs.github.com/en/github/using-git/configuring-git-to-handle-line-endings#refreshing-a-repository-after-changing-line-endings +[github-gui]: https://git-scm.com/downloads/guis +[diffmerge]: https://sourcegear.com/diffmerge/ +[git-it]: https://github.com/jlord/git-it +[git-it-electron]: https://github.com/jlord/git-it-electron +[code-school]: https://www.codeschool.com/ +[try-git]: https://try.github.io +[git-parable]: https://tom.preston-werner.com/2009/05/19/the-git-parable.html +[repos-in-repos]: https://github.com/swcarpentry/git-novice/issues/272 +[cc-faq-software]: https://creativecommons.org/faq/#can-i-apply-a-creative-commons-license-to-software + + + diff --git a/learner-profiles.md b/learner-profiles.md new file mode 100644 index 0000000000..434e335aae --- /dev/null +++ b/learner-profiles.md @@ -0,0 +1,5 @@ +--- +title: FIXME +--- + +This is a placeholder file. Please add content here. diff --git a/md5sum.txt b/md5sum.txt new file mode 100644 index 0000000000..dcc77b42ae --- /dev/null +++ b/md5sum.txt @@ -0,0 +1,24 @@ +"file" "checksum" "built" "date" +"CODE_OF_CONDUCT.md" "c93c83c630db2fe2462240bf72552548" "site/built/CODE_OF_CONDUCT.md" "2023-05-08" +"LICENSE.md" "b24ebbb41b14ca25cf6b8216dda83e5f" "site/built/LICENSE.md" "2023-05-08" +"config.yaml" "69e678021a92f74f922e53d180d05f47" "site/built/config.yaml" "2023-05-08" +"index.md" "9944fa80d27d4d21044683f3efaca6eb" "site/built/index.md" "2023-11-20" +"episodes/01-basics.md" "78184e84f5bf3b0dd88de3918e927591" "site/built/01-basics.md" "2024-06-20" +"episodes/02-setup.md" "5abb7879c09c68c0dbcdec08705ee755" "site/built/02-setup.md" "2024-05-28" +"episodes/03-create.md" "168c21a6a4ecf78bd2cd88700f9da13b" "site/built/03-create.md" "2024-07-03" +"episodes/04-changes.md" "57b35b367e731cf7f620cc0a3841f441" "site/built/04-changes.md" "2024-06-20" +"episodes/05-history.md" "dcae47385da91a86c268ec41bf3d94c1" "site/built/05-history.md" "2024-07-03" +"episodes/06-ignore.md" "0683eb66e0a84b5297827704a1010c7b" "site/built/06-ignore.md" "2023-09-18" +"episodes/07-github.md" "7a9bdeb91c3b2fcc331b8f2f457c7beb" "site/built/07-github.md" "2024-06-20" +"episodes/08-collab.md" "1467e4993e8854f39db4ce9376813355" "site/built/08-collab.md" "2024-06-20" +"episodes/09-conflict.md" "7030a6e8728e09fad34ce0485beff273" "site/built/09-conflict.md" "2024-07-03" +"episodes/10-open.md" "6504a09be66b6c32dc3bc929da9ae50e" "site/built/10-open.md" "2023-05-30" +"episodes/11-licensing.md" "760c89ee6411c89378229180997a4388" "site/built/11-licensing.md" "2023-05-08" +"episodes/12-citation.md" "237b24e4a72f38a36b9d31701f8450f7" "site/built/12-citation.md" "2024-03-27" +"episodes/13-hosting.md" "5de90c2a18e9d00c0dba4d9cd0bf2bf8" "site/built/13-hosting.md" "2023-09-06" +"episodes/14-supplemental-rstudio.md" "1b37aff595bc2f4b3c59f55894a522c7" "site/built/14-supplemental-rstudio.md" "2024-06-20" +"instructors/instructor-notes.md" "8711174c9d3e1f433cdcf9b30cd571d9" "site/built/instructor-notes.md" "2023-09-18" +"learners/discuss.md" "8893316c5cf0dee6a42dd818f6e21122" "site/built/discuss.md" "2023-09-18" +"learners/reference.md" "d976a57639fa49361d9c8431850cde6a" "site/built/reference.md" "2023-05-08" +"learners/setup.md" "19ccf15a75716fe39f1116abf68a380d" "site/built/setup.md" "2023-09-26" +"profiles/learner-profiles.md" "60b93493cf1da06dfd63255d73854461" "site/built/learner-profiles.md" "2023-05-08" diff --git a/reference.md b/reference.md new file mode 100644 index 0000000000..88b7f30695 --- /dev/null +++ b/reference.md @@ -0,0 +1,81 @@ +--- +title: 'Git Cheatsheets for Quick Reference' +--- + +## Git Cheatsheets for Quick Reference + +- Printable Git cheatsheets in several languages are [available here](https://github.github.com/training-kit/) ([English version](https://github.github.com/training-kit/downloads/github-git-cheat-sheet.pdf)). More material is available from the [GitHub training website](https://try.github.io/). +- An [interactive one-page visualisation](https://ndpsoftware.com/git-cheatsheet.html) + about the relationships between workspace, staging area, local repository, upstream repository, and the commands associated with each (with explanations). +- Both resources are also available in other languages (e.g. Spanish, French, and more). +- "[Happy Git and GitHub for the useR](https://happygitwithr.com)" is an accessible, free online book by Jenny Bryan on how to setup and use Git and GitHub with specific references on the integration of Git with RStudio and working with Git in R. +- [Open Scientific Code using Git and GitHub](https://open-source-for-researchers.github.io/open-source-workshop/) - A collection of explanations and short practical exercises to help researchers learn more about version control and open source software. + +## Glossary + +[changeset]{#changeset} +: A group of changes to one or more files that are or will be added +to a single [commit](#commit) in a [version control](#version-control) +[repository](#repository). + +[commit]{#commit} +: To record the current state of a set of files (a [changeset](#changeset)) +in a [version control](#version-control) [repository](#repository). As a noun, +the result of committing, i.e. a recorded changeset in a repository. +If a commit contains changes to multiple files, +all of the changes are recorded together. + +[conflict]{#conflict} +: A change made by one user of a [version control system](#version-control) +that is incompatible with changes made by other users. +Helping users [resolve](#resolve) conflicts +is one of version control's major tasks. + +[HTTP]{#http} +: The Hypertext Transfer [Protocol](#protocol) used for sharing web pages and other data +on the World Wide Web. + +[merge]{#merge} +: (a repository): To reconcile two sets of changes to a +[repository](#repository). + +[protocol]{#protocol} +: A set of rules that define how one computer communicates with another. +Common protocols on the Internet include [HTTP](#http) and [SSH](#ssh). + +[remote]{#remote} +: (of a repository) A version control [repository](#repository) connected to another, +in such way that both can be kept in sync exchanging [commits](#commit). + +[repository]{#repository} +: A storage area where a [version control](#version-control) system +stores the full history of [commits](#commit) of a project and information +about who changed what, when. + +[resolve]{#resolve} +: To eliminate the [conflicts](#conflict) between two or more incompatible changes to a file or set of files +being managed by a [version control](#version-control) system. + +[revision]{#revision} +: A synonym for [commit](#commit). + +[SHA-1]{#sha-1} +: [SHA-1 hashes](https://en.wikipedia.org/wiki/SHA-1) is what Git uses to compute identifiers, including for commits. +To compute these, Git uses not only the actual change of a commit, but also its metadata (such as date, author, +message), including the identifiers of all commits of preceding changes. This makes Git commit IDs virtually unique. +I.e., the likelihood that two commits made independently, even of the same change, receive the same ID is exceedingly +small. + +[SSH]{#ssh} +: The Secure Shell [protocol](#protocol) used for secure communication between computers. + +[timestamp]{#timestamp} +: A record of when a particular event occurred. + +[version control]{#version-control} +: A tool for managing changes to a set of files. +Each set of changes creates a new [commit](#commit) of the files; +the version control system allows users to recover old commits reliably, +and helps manage conflicting changes made by different users. + + diff --git a/setup.md b/setup.md new file mode 100644 index 0000000000..fc90de6773 --- /dev/null +++ b/setup.md @@ -0,0 +1,59 @@ +--- +title: Setup +--- + +## Installing Git + +Since several Carpentries lessons rely on Git, please see +[this section of the workshop template][workshop-setup] for +instructions on installing Git for various operating systems. + +- [Git installation on Windows][workshop-setup] +- [Git installation on MacOS][workshop-setup] +- [Git installation on Linux][workshop-setup] + +## Creating a GitHub Account + +You will need an account for [GitHub](https://github.com) to follow episodes 7 & 8 in this lesson. + +1. Go to and follow the "Sign up" link at the top-right of the window. +2. Follow the instructions to create an account. +3. Verify your email address with GitHub. +4. Configure multifactor authentication (see below). + +### Multi-factor Authentication + +In 2023, GitHub introduced a requirement for +all accounts to have +[multi-factor authentication (2FA)](https://docs.github.com/en/authentication/securing-your-account-with-two-factor-authentication-2fa/about-two-factor-authentication) +configured for extra security. +Several options exist for setting up 2FA, which are summarised here: + +1. If you already use an authenticator app, + like [Google Authenticator](https://support.google.com/accounts/answer/1066447?hl=en&co=GENIE.Platform%3DiOS&oco=0) + or [Duo Mobile](https://duo.com/product/multi-factor-authentication-mfa/duo-mobile-app) on your smartphone for example, + [add GitHub to that app](https://docs.github.com/en/authentication/securing-your-account-with-two-factor-authentication-2fa/configuring-two-factor-authentication#configuring-two-factor-authentication-using-a-totp-mobile-app). +2. If you have access to a smartphone but do not already use an authenticator app, install one and + [add GitHub to the app](https://docs.github.com/en/authentication/securing-your-account-with-two-factor-authentication-2fa/configuring-two-factor-authentication#configuring-two-factor-authentication-using-a-totp-mobile-app). +3. If you do not have access to a smartphone or do not want to install an authenticator app, you have two options: + 1. [set up 2FA via text message](https://docs.github.com/en/authentication/securing-your-account-with-two-factor-authentication-2fa/configuring-two-factor-authentication#configuring-two-factor-authentication-using-text-messages) + ([list of countries where authentication by SMS is supported](https://docs.github.com/en/authentication/securing-your-account-with-two-factor-authentication-2fa/countries-where-sms-authentication-is-supported)), or + 2. [use a hardware security key](https://docs.github.com/en/authentication/securing-your-account-with-two-factor-authentication-2fa/configuring-two-factor-authentication#configuring-two-factor-authentication-using-a-security-key) + like [YubiKey](https://www.yubico.com/products/yubikey-5-overview/) + or the [Google Titan key](https://store.google.com/us/product/titan_security_key?hl=en-US&pli=1). + +The GitHub documentation provides [more details about configuring 2FA](https://docs.github.com/en/authentication/securing-your-account-with-two-factor-authentication-2fa/configuring-two-factor-authentication). + +---------------- + +## Preparing Your Working Directory + +We'll do our work in the `Desktop` folder so make sure you change your working directory to it with: + +```bash +$ cd +$ cd Desktop +``` + +[workshop-setup]: https://carpentries.github.io/workshop-template/install_instructions/#git +