Reactive Programming Patterns

Essential reactive expressions, observers, and advanced patterns for Shiny apps

1 Reactive Types

# reactive() - returns values, cacheable
processed_data <- reactive({
  expensive_computation(input$dataset)
})
# Use: processed_data() - call like function

# observe() - side effects, auto-executes
observe({
  updateSelectInput(session, "vars", 
                    choices = names(processed_data()))
})

# observeEvent() - triggered by specific events
observeEvent(input$save_btn, {
  save_data(processed_data(), input$filename)
})

Key Differences

reactive(): Returns values • Lazy evaluation • Cacheable
observe(): Side effects • Eager execution • No return value
observeEvent(): Event-triggered • User control • Precise timing

2 User-Controlled Execution

# eventReactive - expensive computation on demand
analysis_result <- eventReactive(input$run_analysis, {
  expensive_analysis(filtered_data(), input$params)
})

# Multiple trigger events
report_data <- eventReactive(c(input$generate, input$refresh), {
  create_report(analysis_result())
})

# Event with conditions
validated_result <- eventReactive(input$submit, {
  req(input$required_field)
  validate(need(input$value > 0, "Value must be positive"))
  process_data(input$value)
})

Performance Tip: Use eventReactive() for expensive operations that users should control

3 Breaking Dependencies

# isolate() - access without dependency
analysis <- reactive({
  data <- filtered_data()        # Creates dependency
  params <- input$analysis_params  # Creates dependency
  
  # These don't create dependencies:
  user_notes <- isolate(input$notes)
  timestamp <- isolate(Sys.time())
  
  run_analysis(data, params, user_notes, timestamp)
})

# Observer with selective dependencies
observe({
  # Reacts to data changes
  current_data <- filtered_data()
  
  # Update UI without creating circular dependency
  current_selection <- isolate(input$selected_vars)
  updateSelectInput(session, "selected_vars",
                    choices = names(current_data),
                    selected = current_selection)
})

Use Cases

Metadata: Timestamps, user info, session data
UI Updates: Prevent circular dependencies
Conditional Logic: Access values for comparisons

4 State Management

# reactiveValues - complex state management
app_state <- reactiveValues(
  current_page = 1,
  items_per_page = 10,
  selected_items = character(0),
  filter_active = FALSE
)

# reactiveVal - single reactive value
counter <- reactiveVal(0)

# Update reactive values
observeEvent(input$next_page, {
  app_state$current_page <- app_state$current_page + 1
})

observeEvent(input$increment, {
  counter(counter() + 1)
})

# Use in reactive expressions
current_data <- reactive({
  start_row <- (app_state$current_page - 1) * app_state$items_per_page + 1
  end_row <- start_row + app_state$items_per_page - 1
  slice(full_data(), start_row:end_row)
})

State Tip: Use reactiveVal() for single values, reactiveValues() for complex state objects

5 Input Validation

# req() - conditional execution
filtered_data <- reactive({
  req(input$dataset)           # Wait for dataset
  req(input$filter_column)     # Wait for column selection
  req(input$filter_value)      # Wait for filter value
  
  data <- get_data(input$dataset)
  data[data[[input$filter_column]] > input$filter_value, ]
})

# validate() - user-friendly error messages
output$analysis_plot <- renderPlot({
  data <- filtered_data()
  
  validate(
    need(nrow(data) > 0, "No data matches current filters"),
    need(ncol(data) > 1, "Need at least 2 columns"),
    need(input$x_var %in% names(data), "X variable not found")
  )
  
  create_plot(data, input$x_var, input$y_var)
})

# Combined validation pattern
safe_analysis <- reactive({
  req(input$run_analysis > 0)  # Require button click
  
  data <- filtered_data()
  validate(need(nrow(data) >= 10, "Need at least 10 rows"))
  
  tryCatch({
    complex_analysis(data)
  }, error = function(e) {
    validate(paste("Analysis failed:", e$message))
  })
})

Validation Strategy

req(): Silent waiting for valid inputs
validate(): User-friendly error messages
tryCatch(): Handle unexpected errors gracefully

6 Performance & Debug

# GOOD: Shared reactive expression
expensive_data <- reactive({
  expensive_computation(input$params)
})

output$plot1 <- renderPlot({ plot1(expensive_data()) })
output$plot2 <- renderPlot({ plot2(expensive_data()) })

# BAD: Repeated computation
# output$plot1 <- renderPlot({ plot1(expensive_computation(input$params)) })
# output$plot2 <- renderPlot({ plot2(expensive_computation(input$params)) })

# Debug reactive execution
debug_reactive <- reactive({
  cat("Processing at", as.character(Sys.time()), "\n")
  result <- process_data(input$dataset)
  cat("Processed", nrow(result), "rows\n")
  result
})

# Prevent infinite loops
values <- reactiveValues(counter = 0)

# GOOD: Event-driven update
observeEvent(input$increment, {
  values$counter <- values$counter + 1
})

# BAD: Would create infinite loop
# observe({ values$counter <- values$counter + 1 })

Debug Tip: Use options(shiny.reactlog=TRUE) then reactlogShow() to visualize reactive flow

Master Advanced Shiny Patterns?

Get exclusive cheatsheets, advanced tutorials, and reactive programming tips delivered to your inbox. Join thousands of developers building better Shiny applications!

Advanced patterns & best practices • Performance optimization tips • Unsubscribe anytime

Ready to Master Reactive Programming?

Dive deeper into advanced Shiny development with our comprehensive tutorials

Complete Reactive Guide Advanced State Management Performance Optimization

From reactive basics to enterprise patterns • Advanced debugging techniques • Production-ready examples

Shiny App Structure Cheatsheet: Essential Quick Reference

Master the fundamentals with visual examples and ready-to-use code snippets

Shiny R Beginner Cheatsheet