Reports and Apps

R Tidyverse Extended: Reports and Apps 📊✨

Imagine you’re a chef. You’ve cooked an amazing meal (your data analysis). But how do you serve it beautifully? That’s what R Markdown and Shiny do—they’re your fancy plates and live cooking shows!

🎯 What You’ll Learn

Think of this journey like building a restaurant:

1. R Markdown = Your beautiful menu (documents that show your work)
2. Shiny Apps = Your live cooking station (interactive apps people can use)

📝 R Markdown Basics

What is R Markdown?

Imagine writing a letter to a friend. But this letter is magical—it can run code AND show the results!

R Markdown is like a magic notebook where you can:

• Write words (like a story)
• Add code (that actually runs!)
• Show pictures, charts, and results

Real Life Example:

• A scientist writes their experiment + results in one place
• A teacher creates worksheets that show step-by-step math
• You create a report that updates automatically!

The Three Parts of R Markdown

Every R Markdown file has 3 ingredients:

┌─────────────────────────────────┐
│  1. YAML Header (the recipe)    │
│     Title, author, output type  │
├─────────────────────────────────┤
│  2. Text (the story)            │
│     Your explanations           │
├─────────────────────────────────┤
│  3. Code Chunks (the magic)     │
│     R code that runs!           │
└─────────────────────────────────┘

Your First R Markdown File

---
title: "My First Report"
author: "Your Name"
date: "2024-01-15"
output: html_document
---

This is the YAML header—it’s like the cover page of your book!

After the header, you write normal text:

# Introduction

This is my amazing report about cats!

Simple, right? Just like writing in a notebook!

🧩 R Markdown Code Chunks

What Are Code Chunks?

Think of code chunks like little windows into a computer lab inside your document.

When you open a window (start a chunk), R runs your code. When you close it, the results appear in your document!

Creating a Code Chunk

A code chunk looks like this:

```{r}
# This code will run!
2 + 2
```

The result shows up automatically:

[1] 4

Naming Your Chunks

Give chunks names like you name your pets:

```{r my-first-plot}
plot(1:10)
```

Why name them?

• Easy to find later
• Better error messages
• Organized reports

Chunk Options—The Remote Control

Chunk options control what you see:

Example—Hide the Code, Show Results:

```{r, echo=FALSE}
# User sees only the plot, not this code!
library(ggplot2)
ggplot(mtcars, aes(mpg, hp)) +
  geom_point()
```

Global Options—Rules for Everyone

Set rules for ALL chunks at the top:

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

This is like posting classroom rules that everyone follows!

📤 R Markdown Output Formats

Your Report Can Wear Different Outfits!

The same R Markdown file can become:

┌─────────────────────────────────────────┐
│         YOUR .Rmd FILE                  │
│              │                          │
│     ┌────────┼────────┐                 │
│     ▼        ▼        ▼                 │
│   HTML    PDF     Word                  │
│  (web)  (print)  (edit)                 │
└─────────────────────────────────────────┘

HTML Documents

---
output: html_document
---

Perfect for:

• Sharing online
• Interactive charts
• Anyone with a browser

Fancy HTML Options:

---
output:
  html_document:
    toc: true          # Table of contents
    toc_float: true    # Floating sidebar
    theme: flatly      # Pretty colors
    code_folding: hide # Hide/show code
---

PDF Documents

---
output: pdf_document
---

Perfect for:

• Printing
• Academic papers
• Official reports

Note: You need LaTeX installed!

Word Documents

---
output: word_document
---

Perfect for:

• Colleagues who love Word
• Documents that need editing
• Business reports

Multiple Outputs at Once!

---
output:
  html_document:
    toc: true
  pdf_document: default
  word_document: default
---

Now you can create all three!

🏗️ Shiny App Structure

What is Shiny?

If R Markdown is a book, Shiny is a video game!

Shiny creates live, interactive apps where users can:

• Click buttons
• Move sliders
• See results update instantly

The Two Actors in Every Shiny Play

Every Shiny app has two parts:

┌─────────────────────────────────┐
│           SHINY APP             │
│                                 │
│  ┌─────────┐    ┌───────────┐  │
│  │   UI    │◄──►│  SERVER   │  │
│  │ (Stage) │    │ (Backstage)│  │
│  └─────────┘    └───────────┘  │
│                                 │
│  What users     What happens    │
│  see & click    behind scenes   │
└─────────────────────────────────┘

The Basic Shiny App Template

library(shiny)

# UI - What users see
ui <- fluidPage(
  titlePanel("My App"),
  # Your buttons, inputs, outputs go here
)

# Server - The brain
server <- function(input, output) {
  # Your calculations and logic go here
}

# Run the app
shinyApp(ui = ui, server = server)

That’s it! Three parts:

1. ui — The stage
2. server — The backstage crew
3. shinyApp() — “Lights, camera, action!”

File Structure Options

Option 1: Single File (app.R)

myapp/
  └── app.R

Option 2: Two Files (for bigger apps)

myapp/
  ├── ui.R
  └── server.R

🎨 Shiny UI Components

Building Blocks of Your App’s Stage

Think of UI components like LEGO blocks!

Layout: The Stage Design

fluidPage — Responsive, stretchy layout:

ui <- fluidPage(
  titlePanel("Welcome!"),
  sidebarLayout(
    sidebarPanel(
      # Controls go here
    ),
    mainPanel(
      # Results go here
    )
  )
)

This creates:

┌────────────────────────────────────┐
│        Welcome!                    │
├──────────┬─────────────────────────┤
│          │                         │
│ Controls │      Results            │
│          │                         │
│          │                         │
└──────────┴─────────────────────────┘

Input Components—Getting User Choices

Inputs are like asking questions!

Example—A Slider:

sliderInput(
  inputId = "num",      # ID (for server)
  label = "Pick a number:",
  min = 1,              # Lowest
  max = 100,            # Highest
  value = 50            # Starting point
)

Output Placeholders—Where Results Appear

Outputs are like empty picture frames waiting for art:

Example—A Plot Placeholder:

mainPanel(
  plotOutput("myPlot")  # Empty frame for a plot
)

⚙️ Shiny Server Function

The Backstage Magic

The server function is where the real work happens:

server <- function(input, output) {
  # input = what user chose
  # output = what user sees
}

Reading Inputs

Access user choices with input$id:

server <- function(input, output) {
  # If user moved slider with id "num"
  user_choice <- input$num
}

Creating Outputs

Use render* functions to create content:

Example—Show What User Picked:

server <- function(input, output) {
  output$result <- renderText({
    paste("You picked:", input$num)
  })
}

Complete Mini App Example

library(shiny)

ui <- fluidPage(
  titlePanel("Number Doubler"),

  sidebarLayout(
    sidebarPanel(
      sliderInput("num",
        "Pick a number:",
        min = 1, max = 50, value = 5)
    ),
    mainPanel(
      textOutput("doubled"),
      plotOutput("barPlot")
    )
  )
)

server <- function(input, output) {

  output$doubled <- renderText({
    paste("Double is:", input$num * 2)
  })

  output$barPlot <- renderPlot({
    barplot(input$num, col = "steelblue")
  })
}

shinyApp(ui = ui, server = server)

Reactive Expressions—Smart Calculations

When calculations are expensive, use reactive():

server <- function(input, output) {

  # Calculate once, use many times
  doubled <- reactive({
    input$num * 2
  })

  output$text1 <- renderText({
    paste("Result:", doubled())  # Note the ()
  })

  output$text2 <- renderText({
    paste("Plus 10:", doubled() + 10)
  })
}

Reactives are like recipes—you write them once and use them whenever needed!

🌟 Putting It All Together

The Journey Map

┌─────────────────────────────────────────────┐
│                                             │
│  📝 R Markdown                              │
│     │                                       │
│     ├── Basics (YAML + Text + Code)         │
│     │                                       │
│     ├── Code Chunks (```{r} ... ```)        │
│     │     └── Options: echo, eval, etc.     │
│     │                                       │
│     └── Outputs (HTML, PDF, Word)           │
│                                             │
│  🎮 Shiny Apps                              │
│     │                                       │
│     ├── Structure (ui + server + run)       │
│     │                                       │
│     ├── UI Components                       │
│     │     ├── Inputs (slider, text, etc.)   │
│     │     └── Outputs (plot, text, etc.)    │
│     │                                       │
│     └── Server Function                     │
│           ├── input$ (read user choices)    │
│           ├── output$ (send results)        │
│           └── reactive() (smart calcs)      │
│                                             │
└─────────────────────────────────────────────┘

🎓 Key Takeaways

1. R Markdown = Documents that run code and look beautiful
2. Code Chunks = Magic windows where R code runs inside your document
3. Output Formats = Same file, different outfits (HTML, PDF, Word)
4. Shiny Structure = UI (stage) + Server (backstage) + Run
5. UI Components = Inputs (ask user) + Outputs (show results)
6. Server Function = The brain that connects inputs to outputs

🚀 You Did It!

You now know how to:

• ✅ Create beautiful reports with R Markdown
• ✅ Control code chunks like a pro
• ✅ Export to any format you need
• ✅ Build interactive Shiny apps
• ✅ Design user interfaces
• ✅ Write server logic that responds to users

Your data analysis can now reach the world—through documents AND live apps! 🎉