R Shiny course

Lesson 1 • Setting Up the R Environment

Install R, RStudio, and essential packages needed for Shiny development. Establishes the baseline toolchain for all subsequent chapters.

Lesson 2 • Anatomy of a Shiny App

Examine the ui, server, and shinyApp components that form every Shiny application. Connects R fundamentals to the Shiny execution model.

Lesson 3 • Core R Syntax for Shiny

Review vectors, data frames, functions, and control flow as used inside Shiny apps. Provides the R fluency required before writing reactive code.

Lesson 1 • Layout Functions and Page Types

Explore fluidPage, navbarPage, and fillPage to control overall app structure. Choosing the right page type determines how content scales across screen sizes.

Lesson 2 • Input Widgets Catalog

Implement text, numeric, date, select, checkbox, radio, and slider inputs. Each widget maps to a named input value consumed by the server function.

Lesson 3 • Styling the UI with HTML and CSS

Apply inline styles, custom CSS files, and Shiny's HTML helper functions to refine visual appearance. Prepares students for theming with bslib in later chapters.

Lesson 4 • Sidebar and Panel Layouts

Use sidebarLayout, sidebarPanel, and mainPanel to separate controls from output. This pattern is the most common Shiny UI convention and underpins later dashboard work.

Lesson 1 • Reactive Expressions

Create reactive() expressions to cache intermediate computations shared across multiple outputs. Reduces duplicated code and improves app performance.

Lesson 2 • Reactive Values and State

Store mutable application state using reactiveValues() and reactiveVal(). Enables features like undo history, counters, and session-level data accumulation.

Lesson 3 • Observers and Side Effects

Use observe() and observeEvent() to trigger side effects such as writing files or updating inputs. Distinguishes reactive producers from reactive consumers.

Lesson 4 • Isolating and Controlling Reactivity

Apply isolate(), req(), and validate() to control when and how reactive code executes. Prevents premature execution and provides user-friendly error messages.

Lesson 1 • Rendering Static and Interactive Plots

Produce base R, ggplot2, and plotly visualizations inside Shiny output slots. Interactive plots enable click and hover events used in later chapters.

Lesson 2 • Notifications and Progress Indicators

Provide user feedback during long operations using showNotification() and withProgress(). Improves perceived performance and communicates app state clearly.

Lesson 3 • File Downloads and Uploads

Implement downloadHandler() for CSV and PDF exports and fileInput() for user-supplied data. Closes the data ingestion and export loop in a complete app.

Lesson 4 • Text and Verbatim Output

Display dynamic strings and raw R output using renderText() and renderPrint(). Forms the simplest output type and validates that reactivity is wired correctly.

Lesson 1 • Filtering Data Reactively

Apply dplyr filter() inside reactive expressions driven by widget inputs. Reactive filtering is the core pattern for exploratory data apps.

Lesson 2 • Handling Missing and Dirty Data

Detect and handle NA values, type mismatches, and malformed inputs before rendering. Prevents cryptic errors and ensures outputs remain meaningful.

Lesson 3 • Connecting Data Sources to Apps

Load CSV, Excel, and RDS files at startup or reactively based on user input. Proper data loading strategy determines app startup time and memory use.

Lesson 4 • Transforming and Summarizing Data

Use mutate(), group_by(), and summarize() inside reactive pipelines to derive new metrics. Transformed data feeds both plot and table outputs simultaneously.

Lesson 1 • Structuring Large Shiny Projects

Organize code across R/, www/, and data/ directories following the golem and standard conventions. Good structure reduces onboarding time and merge conflicts.

Lesson 2 • Building Apps as R Packages

Wrap a Shiny app inside an R package using golem to gain documentation, testing, and dependency management. Package structure is the industry standard for production apps.

Lesson 3 • Passing Data Between Modules

Return reactive values from modules and pass them as arguments to sibling modules. Enables complex multi-module data flows without global state.

Lesson 4 • Introduction to Shiny Modules

Encapsulate UI and server logic into namespaced module functions using moduleServer(). Modules prevent ID collisions and enable component reuse across apps.

Lesson 1 • Optimizing Data and Rendering

Reduce data transferred to the browser by pre-aggregating server-side and using efficient output formats. Smaller payloads directly improve time-to-interactive for end users.

Lesson 2 • Asynchronous Programming with Promises

Offload slow operations to background processes using the promises and future packages. Async execution prevents one user's slow query from blocking all other sessions.

Lesson 3 • Profiling App Performance

Use profvis and reactlog to identify slow reactive chains and rendering bottlenecks. Profiling before optimizing prevents wasted effort on non-critical code paths.

Lesson 4 • Scaling with Shiny Server and Load Testing

Configure worker processes and conduct load tests using shinyloadtest to find capacity limits. Load testing before launch prevents outages under real user traffic.

Lesson 1 • Authentication and Access Control

Restrict app access using Posit Connect permissions, shinymanager, or OAuth integrations. Protects sensitive data and satisfies organizational security requirements.

Lesson 2 • Deploying to shinyapps.io

Publish apps to the managed shinyapps.io platform using rsconnect and configure instance settings. The fastest path from local app to a publicly accessible URL.

Lesson 3 • Logging and Error Monitoring

Implement structured logging with the logger package and capture runtime errors for alerting. Observability is essential for diagnosing issues in production without user reports.

Lesson 4 • Continuous Deployment Pipelines

Automate testing and deployment using GitHub Actions and rsconnect CLI on every code push. CI/CD eliminates manual deployment steps and enforces quality gates.