lab4.Rmd

---
title: "Lab 4 - Introduction to RStudio and R Markdown. Presentations"
author: Austin Shih
date: Oct. 1, 2023 
output:
  html_document:
    toc: true
editor_options: 
  markdown: 
    wrap: 72
---

<!-- This is a comment in R Markdown (and regular markdown, such as in Jupyter)-->

<!-- The dashes below are not part of the YAML block above, -->

<!-- they insert a horizontal line after the ToC -->

------------------------------------------------------------------------

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

In Lab 4, you will learn how to use, edit and create a R Markdown
document (like this one) using RStudio. You should follow the
instructions in this document to complete the assignment. Knit this
document to view the nicely rendered HTML, which can make it easier to
read the questions.

If you need help as you use R Markdown in this lab and others in the
future, consult the following resources:

-   [Cheat sheet](https://rmarkdown.rstudio.com/lesson-15.html)
-   [Home page with guides](https://rmarkdown.rstudio.com/docs/)
-   [Reference book](https://bookdown.org/yihui/rmarkdown/)

The below is a code chunk, but instead of using the `r` engine we're
creating and alert block that will make the question show up with a blue
background in the HTML output. Unfortunately, this creates and error
when exporting to PDF, so it can only be used for HTML.

```{block, type="alert alert-info"}
## Submission Instructions
rubric={mechanics:2}

You receive mark for submitting your lab correctly, please follow these instructions:

- [Follow the general lab instructions](https://ubc-mds.github.io/resources_pages/general_lab_instructions/).
- [Click here to view a description of the rubrics used to grade the questions](https://github.com/UBC-MDS/public/tree/master/rubric).
- Push your `.Rmd` AND **all the files** you will create as part of the lab to your GitHub repository.
    - The reason for pushing all the files is that `.Rmd` does not contain the rendered output
      from running the cells.
      If someone is checking out your work
      there needs to be an HTML file to view the output,
      so it is good to get into this habit.
          - `.ipynb` renders nicely on GitHub,
            which is why we did not include the HTML file for previous labs.
- Upload a `.Rmd` version of your assignment to Gradescope.
- Include a clickable link to your GitHub repo for the lab just below this cell (it should look something like this https://github.ubc.ca/MDS-2022-23/DSCI_521_labX_yourcwl.
```

<https://github.ubc.ca/MDS-2022-23/DSCI_521_lab4_austinsh>

## Editing R Markdown documents

This document is called an R Markdown document. It is a literate code
document, similar to Jupyter notebooks where you can write code and view
its outputs. To start, let's set our working directory by creating a new
R Project for lab 4.

### Text and rendering R Markdown documents

In a R Markdown document any line of text not in a code chunk (like this
line of text) will be formatted using Markdown. Similar to JupyterLab,
you can also use HTML and LaTeX here to do more advanced formatting. To
run a code chunk, you can press the green play button in the top right
corner of the chunk.

```{block, type="alert alert-info"}
#### Question 1
rubric={correctness:1}

To render the HTML files we are going to create, the first step is to activate GitHub pages.


```

<https://github.com/austin-shih/DSCI_521_lab4>

```{block, type="alert alert-info"}
#### Question 2
rubric={mechanics:1}

Create a new code chunk below using the r language engine that runs some R code
(it does not need to be complicated,
but it should have an output).
Ensure that you can render/knit the document after you add that chunk.
```

```{r}
x <- 5
y <- 2
print(x + y)
```

```{block, type="alert alert-info"}
#### Question 3
rubric={mechanics:1}

Create a new code chunk,
and add a meaningful name to the code chunk.
Try using the pop-up-like menu to navigate between the named code chunks
Don't forget to knit/render the document
after you make this change to ensure everything is still working.
```

```{r Q3 Code Chunk}
a <- 10
b <- 12
c <- a * b
print(c)
```

```{block, type="alert alert-info"}
#### Question 4
rubric={mechanics:1,reasoning:1}

Create a new code chunk that uses a code chunk option.
Write out in your own words what the code chunk option is doing.
```

```{r Q4 Code Chunk, echo=FALSE}
d <- 121
e <- 2
f <- d^(1/e)
print(f)
```

    The above option runs the code chunk but only shows the output and not the code itself.

#### Multiple code chunk options

To have multiple code chunk options you separate them by a comma. For
example, if in addition to suppressing warnings, we want to run the code
but not output the results, then we can add the `include = FALSE`
argument to the code chunk after the `warning = FALSE` option.

```{block, type="alert alert-info"}
#### Question 5
rubric={mechanics:1,reasoning:1}

Create a new code chunk that uses at least two code chunk options.
At least one must be different to the ones mentioned above.
Write in your own words what each code chunk option is doing.
```

```{r Q5 Code Chunk, error = TRUE, echo = TRUE, highlight = TRUE}
g <- "hello world"
h <- 2023
paste(g, h)
```

- error=TRUE will display any error messages from this code chunk\
- echo=TRUE will display the code in this code chunk after it is knit\
- highlight=TRUE will highlight the code in this code chunk after it is knit

### 1.5. YAML Header and document output options

R Markdown files contains three types of content:

1.  Plain text mixed with simple Markdown formatting.
2.  Code chunks surrounded by <code>\`\`\`</code>.
3.  An (optional) YAML header surrounded by `---`.

You have been introduced the first two types of content, but not the
third (although you probably saw it at the top of this document). The
(optional) YAML header, which is located at the very top of R Markdown
files sets some general global parameters, including:

-   title
-   author
-   output
-   etc

**Example YAML Header**

    ---
    title: "Reproducible Data Science Report"
    author: "Florencia D'Andrea"
    date: "September 4, 2022"
    output: html_document
    ---

Most important from a workflow perspective is **output**. Possible
output options include:

-   `output: html_document`
-   `output: md_document`
-   `output: pdf_document`
-   `output: word_document`
-   `output: xaringan::moon_reader` (xaringan presentation - html)

```{block, type="alert alert-info"}
#### Question 6
rubric={mechanics:1}

Navigate to the YAML header at the very top of this document
and edit it so that you include an `author` (yourself) and a `date` (lab due date).
Include what you added below here as well as a fenced Markdown code block.
```

    Added 'author: Austin Shih' and 'date: Oct. 1, 2023' to YAML header

### Creating R Markdown documents

You can use the "File" menu inside RStudio to create new R Markdown
documents by selecting: **File \> New File \> R Markdown** This will
bring you to another menu where you can choose the type of output (don't
be afraid to pick something, you can always change the `output` type
once you have the `.Rmd` file).

To create a written report, we generally recommend using the default
`output: html_document` as it is easier to read than PDF (note - LaTeX
does not render nicely in such documents sadly, so if you are using a
lot of LaTeX then you may want to choose `output: pdf_document`). If you
want to create an `.md` file to publish on GitHub, it is recommend to
instead use `output: github_document`. To get this from the menu above
you need to navigate to the "From Template" option on the left panel and
then select "GitHub Document (Markdown)".

```{block, type="alert alert-info"}
#### Question 7
rubric={mechanics:2}

1 - Create a new RMarkdown report (a different file than this one) 
in the same directory as this RMarkdown file.
Use `html_document` as the `output`.
After you have rendered it, paste the link to the HTML output
as a link to your GitHub repository
(remember to push all your files!)

2 - Then, navigate to the YAML header at the very top of that `.Rmd` document
and edit it so that the `output` is `pdf_document`.
Then knit/render the document.
Note the different output.
Add and commit that rendered both the `.html` and `.pdf` files
to the GitHub repository for this lab
and paste the two links below this question.
```

-   .Rmd file link
    <https://github.ubc.ca/MDS-2022-23/DSCI_521_lab4_austinsh/blob/master/521_lab4_Q7.Rmd>

1.  <https://github.ubc.ca/MDS-2022-23/DSCI_521_lab4_austinsh/blob/master/521_lab4_Q7.html>
2.  <https://github.ubc.ca/MDS-2022-23/DSCI_521_lab4_austinsh/blob/master/521_lab4_Q7.pdf>

```{block, type="alert alert-info"}
#### Question 8
rubric={mechanics:6}

1. Go back to the `.Rmd` file you created in question 7,
   and include at least two Markdown text sections
   (each should have a header)
   and at least two separate code chunks in it (these can be really simple).
   Save the new R Markdown document and give it a new meaningful name.

2. Render/knit the new R Markdown document to get an `.html` file.
   Put the `.Rmd` document
   and the rendered `.html` file under version control using Git,
   and push/upload the file to your GitHub repository for this homework.
   Paste a link to these files as your answer below.
```

-   .Rmd file link:
    <https://github.ubc.ca/MDS-2022-23/DSCI_521_lab4_austinsh/blob/master/521_lab4_Q8.Rmd>
-   html link:
    <https://github.ubc.ca/MDS-2022-23/DSCI_521_lab4_austinsh/blob/master/521_lab4_Q8.html>

```{block, type="alert alert-info"}
#### Question 9 (Optional)
rubric={mechanics:1,reasoning:1}

1. Take the R Markdown report created in Question 8
   and change the output to `github_document` and render it.
   Put the rendered `.md` file under version control using Git,
   and push/upload the file to your GitHub repository for this homework.
   Try to look at the file on GitHub.ubc.ca in your homework repo?
   What do you see? How is it rendered?
```

-   <https://github.ubc.ca/MDS-2022-23/DSCI_521_lab4_austinsh/blob/master/521_lab4_Q9.md>
-   The .md file has rendered in a way that text sections can be viewed
    and code chunks can be copied on Github. Unlike html which just
    rendered the raw code on Github or the pdf render which just save an
    un-editable pdf file, the .md file can be viewed and edited on
    Github.

```{block, type="alert alert-info"}
#### Question 10
rubric={mechanics:6}

1. Create a presentation using RStudio.
   Do this in a different file than this one but in the same directory as this RMarkdown file.
   You can use xaringan or Quarto to create the slides. 
   [On the book](https://pages.github.ubc.ca/MDS-2022-23/DSCI_521_platforms-dsci_students/materials/lectures/8-rmarkdown-quarto-slides-ghpages.html) you will find links
   that will guide you on how to create each type of slide.
   If you are not sure which one to use, 
   it is safer to use Xaringan as Quarto is quite new and
   you will have to learn how to use `.qmd` files.
   But if you want to explore Quarto, 
   we will accept both options (Xaringan or Quarto slides)
   as correct.
   Give this file a meaningful name.
2. Create at least 4 slides.
   At least two slides must include a code chunk or cell (these can be really simple).
   Save the new document.
3. Render/knit the new document to get a `html` presentation file.
4. Put the new document and the rendered `.html` file under version control using Git,
   and push/upload the file to your GitHub repository for this lab
5. Activate GitHub pages and paste the link below.
```

<https://austin-shih.github.io/DSCI_521_lab4/521_lab4_Q10.html#1>

```{block, type="alert alert-info"}
#### (Challenging) Question 11
rubric={reasoning}

In a paragraph or two,
compare and contrast the use of reproducible tools
(e.g., R Markdown and Jupyter)
and non-reproducible tools
(Word, Powerpoint, Keynote, etc)
for presentations and reports.
Include advantages and disadvantages for each.
```

YOUR ANSWER GOES HERE