Reproducible Research Workshop

• The original data (and original computer code) can be analyzed by an independent investigator to obtain the same results of the original study.
• My own goal: all analyses are scripted: tables, figures, parameter values in the manuscript. Nothing is done "by hand".

• For your future self who is much less intelligent than your present genius self
• For your collaborators and for others to build upon
• Easily change documents when assumptions or data change
• Preserve context on why analyses were performed in certain way

• My experience with the DOI/USDA Fire Fire Surrogate study
• My current microclimate modeling project

https://etherpad.mozilla.org/2015-05-13-rr-workshop

Open a terminal (bash)

ls
cd ~/rr-workshop
ls
cd course-materials/examples
ls
echo "hello"
echo "hello" > newfile.txt
cat newfile.txt
cd shell
ls
cd ..

Use tab to autocomplete!

cd ~/rr-worskop/course-materials/examples/
ls *.R
ls *.r*

find, cat, less

cd shell
ls -al
find . -print
cat MC/MC607.csv
less MC/MC607.csv

Some commands in less:

wc GP/*.csv MC/*.csv

One file is much shorter than others, why?

head MC/MC607.csv -n2
tail MC/MC607.csv -n2
head MC/MC606.csv -n2
tail MC/MC606.csv -n2

There must be missing data in the middle

Find temperatures for measurements between 8 and 9 AM on Jan 1, 2014 in all MC locations.

grep searches for patterns (regular expressions) in files

grep "1/1/14 8:..:.. AM" MC/*.csv

# and in all files in this folder and below:

grep -r "1/1/14 8:..:.. AM" .

"Pipe" the output of one command as input to another

wc GP/*.csv MC/*.csv
wc GP/*.csv MC/*.csv | tail -n1
wc GP/*.csv MC/*.csv | grep "total"

• file … new project
• select the folder into which you cloned "rr-worskhop"
• See that there is a git icon and some options under the tools menu now
• set the working directory to the course-materials/examples folder
• open birdd.R in the examples folder

4.0 * 3.5
log(10)  # natural log
log10(10)
(3 + 1) * 5
3^-1
1/0

[1] 14
[1] 2.302585
[1] 1
[1] 20
[1] 0.3333333
[1] Inf

Functions are modules of code that accomplish a specific task. Functions usually take data as "arguments" and "return" a result. Once a function is written, it can be used over and over and over again. Functions can be "called" from within other functions.

Arguments to R functions can be matched by position or by name. So the following calls to sd() are all equivalent

mydata <- rnorm(100)
sd(mydata)
sd(x = mydata)
sd(x = mydata, na.rm = FALSE)
sd(na.rm = FALSE, x = mydata)
sd(na.rm = FALSE, mydata)

runif(5)

[1] 0.0705746 0.7757365 0.2578603 0.3275505 0.6414583

runif(5, 0, 10)

[1] 10  0  5 10  9

floor(runif(5,0,11))

[1] 10  0  5 10  9

x <- 1:20
x

[1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20

getwd()
# setwd(path.expand("~/") )

In Rstudio: Session…Set Working Directory

• set working dir to "rr-workshop/course-materials/examples"
• Walk through code and test visualizations

To make our research as reproducible and visible as possible

• Ubiquitous
• Usually small in size
• Portable across platforms (and versions)
• Use one powerful text editing tool for everything you do.
• Version control: VC systems work best on text files (eg git)

Most output is based on simple text file. There are two main final formats: HTML and PDF. One is pageless and one is centered on the idea of the printed page.

• Syntax highlighting
• Braces, parenthesis matching, automatic indenting, wrapping comments
• Ability to work with multiple interpreters (R, Bash, Python, Julia . . .)
• Spell checking

And some other things you did not know you wanted: TODOs and outlining modes, exporting to HTML or PDF, web browsing, email …

• A lightweight markup language (less complicated and less powerful than \LaTex, for example
• The standard for integrating text and results with R code using RMarkdown files and knitr
• standard source format for structured text in many places now (GitHub, jekyll web sites, etc
• "Academic markdown" is maturing with support for using reference databases, citation styles, etc.

## My Paper ##

I just discovered that:

$$e=Mc^2$$

### My Table ###

| Left | right | center |
|------|-------|--------|
| data | 0.01  | 2.3    |

*italic*, **bold**

unordered list:
- item 1
- item 2
- item 3

Ordered list:
1. item 1
2. item 2
3. item 3

Heading1
========

# Heading1 #

Heading2
--------

## Heading 2 ##

### Heading 3 ###

Links:

http://daringfireball.net/projects/markdown/syntax
[Markdown syntax](http://daringfireball.net/projects/markdown/syntax)
[Markdown syntax][mkdn]

[mkdn]: http://daringfireball.net/projects/markdown/syntax

Just use LateX math!

$$\frac{n!}{k!(n-k)!} = \binom{n}{k}$$

Inline equations just need a single $

In ecology, "true" species diversity is:
$ D_q = \frac{1}{\sqrt[q-1]{\sum_{i=1}^R{p_{i} p_{i}^{q-1}}}}

So how do we glue everything together and produce wonderful htmls and pdfs out of thin air?

With pandoc: http://johnmacfarlane.net/pandoc/

Figure from Kieran Healy: http://kieranhealy.org/resources/

See http://rmarkdown.rstudio.com/

Can aid in reproducible research: Simply combine text and code

Plain R script

Simplest. This is how I teach my graduate programming course. Encourage use of comments and require that script run from top to bottom without error. In RStudio, one can compile this to an RMarkdown file (Compile Notebook command).

knitr

http://yihui.name/knitr/. R package. Mix text and code and "knit" to output. Can work with LaTeX (rnw files) and with RMarkdown (Rmd).

knitr is an R package that can interpret .rnw files (LaTeX) or RMarkdown files (.Rmd) with R code blocks and "knit" them into LaTeX or markdown (.md) files that can be processed to html, pdf, etc (eg with pandoc)

RMarkdown example
=================

## some code
```{r mpg-data-plot, fig.width=4, fig.height=4}

library(ggplot2)
qplot(displ, hwy, data=mpg)

```
# Another heading
Some data:
```{r}
head(mpg)
```

Reproducible research in R (see Yihui Xie's Dynamic Documents with R and knitr)

• Use relative, not absolute, file paths and keep a whole project in one directory whenever possible
• Don't change the working directory
• Compile your reports in a clean R session to test that they really run (existing R objects gotcha)
• Avoid any commands needing human interaction, and avoid relying on environment variables outside the code; the whole script should be automated and self-contained
• Include instructions on running the document for your collaborators (or future self)

see http://git-scm.com/book/

Hidden directory called .git

.
├── .git
│   ├── branches
│   ├── config
│   ├── description
│   ├── HEAD
│   ├── hooks
│   │   ├── applypatch-msg.sample
│   │   ├── commit-msg.sample
│   │   ├── post-update.sample
│   │   ├── pre-applypatch.sample
│   │   ├── pre-commit.sample
│   │   ├── prepare-commit-msg.sample
│   │   ├── pre-push.sample
│   │   ├── pre-rebase.sample
│   │   └── update.sample
│   ├── info
│   │   └── exclude
│   ├── objects
│   │   ├── info
│   │   └── pack
│   └── refs
│       ├── heads
│       └── tags
└── README.md

git status

On branch master

Initial commit

Untracked files:
  (use "git add <file>..." to include in what will be committed)

        README.md

nothing added to commit but untracked files present (use "git add" to track)

git add .
git status

On branch master

Initial commit

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)

        new file:   README.md

git commit -m "initial commit"
git status

On branch master
nothing to commit, working directory clean

A commit is a snapshot taken from the index (staging area) not from the working directory!

git clone https://github.com/schwilklab/protocols.git
cd protocols
ls

./  ../   html/  lab-org/  methods/  README.md  safety/

• Edit files
• Stage the changes (git add)
• Review the changes (git diff)
• Commit the changes (git commit)

git log --pretty=oneline --abbrev-commit -10

d2ec17b Reduce markup lecture
e4d405f Add folder for tangled session files
bb2d29e Add shell (Bash) examples and some data
261af83 Clean up birdd files
e289d7e Minor edit
f2820d3 Scatterplot fig in birdd example
75a4be6 Add slides on Bash shell
66c9a7f Add etherpad link for workshop
e23b559 Suggest getting github.com account
7e6a6df Add time and date for workshop

git diff

difference between working directory and index (staging area)

git diff --staged

difference between index and last commit

With right options, diff can show changes between any two commits, any two files, etc.

Try:

git diff HEAD~1

• open birdd.Rmd
• Explore data together and commit changes

A branch represents an independent line of development.

git checkout <existing-branch>

Merging is Git's way of putting a branched history back together again.

• a version of the repository that hosted somewhere on the internet.
• Remotes have a url (https or ssh), but the can also have names.
• It is common to have only one remote at it is named "origin"

We use GitHub for hosting, so most of of your local repos will be associated with a remote named "origin" and a url something like git@github.com:schwilklab/CSC-sky-island-forest.git

When you clone from a remote, git remembers and calls that remote "origin". You can look at .git/config or, better use git commands to view:

git remote -v

origin  git@github.com:dschwilk/rr-workshop.git (fetch)
origin  git@github.com:dschwilk/rr-workshop.git (push)

If you need to add a remote to an existing repository:

git remote add rem2 git@github.com:dschwilk/software-tools-course.git

git push <remote> <branch name>
eg: git push origin master
or just: git push

This works if none else has pushed changes to that remote since you last pulled. If there is an error, you will need to pull (fetch and merge) first.

idea of "forking"

git add -p

Interactively add changed "hunks".