# Using typeR with Quarto Presentations

    library(typeR)

## Overview

The typeR package provides excellent support for Quarto presentations, allowing you to create engaging live coding demonstrations for:

- 🎓 Teaching - Show students how code is written step-by-step
- 🎤 Conference talks - Demonstrate concepts with live coding effects
- 📹 Tutorial videos - Record professional coding tutorials
- 👥 Workshops - Engage audiences with interactive demonstrations

## Quick Start

### 1. Create a Quarto Presentation

First, create a Quarto presentation file with `reveal.js` format:

    # ---
    # title: "My R Demo"
    # format: revealjs
    # ---

    ## Slide 1

    # ```{r}
    # x <- 1:10
    # mean(x)
    # ```
    #

    ## Slide 2

    # ```{r}
    # plot(x, x^2)
    # ```
    #

Save this as `my-demo.qmd`.

### 2. Run with typeRun()

    # Basic usage
    typeRun("my-demo.qmd")

    # With custom settings
    typeRun("my-demo.qmd", delay = 0.08, jitter = 0.02)

What happens:

- YAML header is skipped automatically
- Slide dividers (`##`) are typed out
- R code chunks execute in real-time
- Narrative text types without executing

## Included Examples

The package includes ready-to-use Quarto presentation examples:

    # Find the example file
    demo_file <- system.file("examples/demo-presentation.qmd", package = "typeR")

    # Run it
    typeRun(demo_file)

    # Or the simpler version
    simple_file <- system.file("examples/simple-presentation.qmd",
                               package = "typeR")
    typeRun(simple_file, delay = 0.05)

## Supported Quarto Formats

`typeR` works with various Quarto presentation formats:

### reveal.js (Default)

    format: revealjs

Most popular format for HTML presentations. Supports themes, transitions, and interactive features.

### PowerPoint

    format: pptx

While the typing effect works during development, the final PowerPoint won’t show animation.

### Beamer (PDF)

    format: beamer

LaTeX-based PDF slides. `typeRun()` helps during development to test code.

## Best Practices

### 1. Adjust Typing Speed

For presentations, slower typing is often better:

    # Slower for readability
    typeRun("presentation.qmd", delay = 0.10, jitter = 0.03)

    # Very slow for teaching
    typeRun("presentation.qmd", delay = 0.15, jitter = 0.05)

    # Fast for quick demos
    typeRun("presentation.qmd", delay = 0.03, jitter = 0.01)

### 2. Control Output Length

Prevent long outputs from scrolling off screen:

    # Limit to 5 lines
    typeRun("presentation.qmd", max_print = 5)

    # Show more for detailed examples
    typeRun("presentation.qmd", max_print = 15)

### 3. Use Interactive Pause

During live presentations, pause to answer questions:

    typeRun("presentation.qmd")
    # Press ESC to pause
    # Enter 1 to resume
    # Enter 2 to stop

### 4. Test Before Presenting

Always do a full run-through before your actual presentation:

    # Full test run
    typeRun("my-talk.qmd", delay = 0.05)

    # Check for errors or unexpected output

## Example: Full Presentation Workflow

### Step 1: Create Content

    ---
    title: "Data Analysis in R"
    format:
      revealjs:
        theme: moon
        transition: slide
    ---

    ## Introduction

    Today we'll analyze the mtcars dataset.

    ## Load Data

    # ```{r}
    # data(mtcars)
    # head(mtcars, 3)
    # ```

    ## Summary Statistics

    # ```{r}
    # summary(mtcars$mpg)
    # ```

    ## Visualization

    # ```{r}
    # plot(mtcars$wt, mtcars$mpg,
    #      xlab = "Weight", ylab = "MPG",
    #      main = "Fuel Efficiency vs Weight")
    # ```

    ## Model

    # ```{r}
    # model <- lm(mpg ~ wt, data = mtcars)
    # summary(model)
    # ```

### Step 2: Practice

    # Save the above as "data-analysis.qmd"
    typeRun("data-analysis.qmd", delay = 0.06, max_print = 8)

### Step 3: Present Live

During your presentation:

1. Open R/RStudio
2. Load typeR: `library(typeR)`
3. Run: `typeRun("data-analysis.qmd", delay = 0.08)`
4. Let the code type out automatically
5. Use ESC to pause for questions

## Advanced Features

### Custom Environment

Keep your workspace clean by using a separate environment:

    # Create isolated environment
    demo_env <- new.env()

    # Run presentation in that environment
    typeRun("presentation.qmd", envir = demo_env)

    # Your global environment remains clean
    ls()  # Nothing added here
    ls(demo_env)  # All demo objects here

### Combining Multiple Presentations

    # Run a series of short demos
    demos <- c("intro.qmd", "advanced.qmd", "qa.qmd")

    for (demo in demos) {
      cat("\n\n=== Starting:", demo, "===\n\n")
      typeRun(demo, delay = 0.06)
      cat("\n\n=== Finished:", demo, "===\n\n")
    }

## Tips for Success

### Do’s ✅

- Practice your presentation multiple times
- Adjust delay to match your speaking pace
- Use max_print to avoid overwhelming output
- Test plots to ensure they display correctly
- Prepare backup - have slides ready if tech fails

### Don’ts ❌

- Don’t type too fast - audience needs time to read
- Don’t show massive outputs - use head() or sample()
- Don’t skip testing - always do a dry run
- Don’t forget ESC pauses if you need to stop

## Troubleshooting

### Issue: Code types too fast

Solution: Increase the delay parameter

    typeRun("presentation.qmd", delay = 0.12)

### Issue: Output is too long

Solution: Use max_print or modify your code to show less

    typeRun("presentation.qmd", max_print = 5)

### Issue: Need to stop mid-presentation

Solution: Press ESC, then choose option 2

### Issue: Plots don’t display

Solution: Make sure your graphics device is open and functioning

    # Test graphics device
    plot(1:10)  # Should work before starting typeRun

## Real-World Use Cases

### Teaching a Course

    # Week 1: Basics
    typeRun("week1-intro.qmd", delay = 0.10)

    # Week 2: Data manipulation
    typeRun("week2-dplyr.qmd", delay = 0.08)

    # Week 3: Visualization
    typeRun("week3-ggplot.qmd", delay = 0.08)

### Conference Talk

    # 20-minute presentation
    typeRun("conference-talk.qmd",
            delay = 0.06,     # Fast enough to keep pace
            max_print = 6)    # Brief outputs

### Workshop

    # Interactive 2-hour workshop
    typeRun("workshop-morning.qmd",
            delay = 0.09,      # Slower for learning
            max_print = 8)

    # Break, then afternoon session
    typeRun("workshop-afternoon.qmd",
            delay = 0.09,
            max_print = 8)

## Getting Help

- Documentation: See `?typeRun` for all parameters
- Examples: Check `inst/examples/` directory
- Issues: Report bugs at https://github.com/Fgazzelloni/typeR/issues
- Community: Share your presentations using #typeR

## Conclusion

typeR makes Quarto presentations more engaging and professional. The combination of:

- ✨ Visual appeal - Typing animation catches attention
- 🎯 Educational value - Shows code construction process
- 💪 Flexibility - Works with any Quarto format
- 🛠️ Ease of use - Just one function call

Makes it an excellent tool for anyone presenting R code.

Happy presenting! 🎉