• Why we care about Reproducibility
• R + markdown = Rmarkdown
• Controling output and input of rmarkdown
• Exercises on creating rmarkdown reports on the humble platypus
• Form up assignment groups
• Quiz
• Release assignment (later today)

Near-term goals:

• Are the tables and figures reproducible from the code and data?
• Does the code actually do what you think it does?
• In addition to what was done, is it clear why it was done? (e.g., how were parameter settings chosen?)

Long-term goals:

• Can the code be used for other data?
• Can you extend the code to do other things?

• Literate programming shines some light on this dark area of science.

• An idea from Donald Knuth where you combine your text with your code output to create a document.

• A blend of your literature (text), and your programming (code), to create something you can read from top to bottom.

So

Imagine a report:

Introduction, methods, results, discussion, and conclusion,

and all the bits of code that make each section.

With rmarkdown, you can see all the pieces of your data analysis all together.

Each time you knit the analysis is ran from the beginning

Provides an environment where you can write your complete analysis, and marries your text, and code together into a rich document.

You write your code as code chunks, put your text around that, and then hey presto, you have a document you can reproduce.

• Every assignment + project / is an R Markdown document
• You'll always have a template R Markdown document to start with
• The amount of scaffolding in the template will decrease over the semester
• These lecture notes are created using R Markdown (!)

There are three parts to an rmarkdown document.

• Metadata (YAML)
• Text (markdown formatting)
• Code (code formatting)

Code chunks are marked by three backticks and curly braces with r inside them:

```{r chunk-name}
# a code chunk
```

Sometimes you want to run the code inside a sentence. This is called running the code "inline".

You might want to run the code inline to name the number of variables or rows in a dataset in a sentence like:

There are XXX observations in the airquality dataset, and XXX variables.

You can call code "inline" like so:

There are `r nrow(airquality) ` observations in the airquality dataset, 
and `r ncol(airquality) ` variables.

Which gives you the following sentence

There are 153 observations in the airquality dataset, and 6 variables.

What's great about this is that if your data changes upstream, then you don't need to work out where you mentioned your data, you just update the document.

• Every chunk should ideally have a name.
• Naming things is hard, but follow these rules and you'll be fine:

1. One word that describes the action (e.g., "read")
2. One word that describes the thing inside the code (e.g, "gapminder")
3. Separate words with "-" (e.g., read-gapminder)

You can control how the code is output by changing the code chunk options which follow the title.

What do you think this does?

• go to rstudio.cloud, open document 01-oz-atlas.Rmd and change the document so that the code output is hidden, but the graphics are shown. (Hint: Google "rstudio rmarkdown cheatsheet" for some tips!)
• Re-Knit the document.
• Take a look at the R Markdown Gallery.

You can set the default chunk behaviour once at the top of the .Rmd file using a chunk like:

knitr::opts_chunk$set(
  echo = FALSE,
  cache = TRUE
)

then you will only need to add chunk options when you have the occasional one that you'd like to behave differently.

• There is a Reproducibility Crisis
• rmarkdown = YAML + text + code
• rmarkdown has many different output types
• Platypus are interesting!
• Assignment will be announced later today

• R Markdown cheat sheet and Markdown Quick Reference (Help -> Markdown Quick Reference) handy, we'll refer to it often as the course progresses

Take the quiz for today from ED.