Mastering shiny : build interactive apps, reports, and dashboards powered by R / Hadley Wickham.

Format:

Book

Author/Creator:

Wickham, Hadley, author.

Language:

English

Subjects (All):

R (Computer program language).

Application software--Development.

Application software.

Web site development.

Physical Description:

1 online resource (xx, 348 pages) : illustrations

Edition:

First edition.

Place of Publication:

Sebastopol, CA : O'Reilly, [2021]

Summary:

Master the Shiny web framework--and take your R skills to a whole new level. By letting you move beyond static reports, Shiny helps you create fully interactive web apps for data analyses. Users will be able to jump between datasets, explore different subsets or facets of the data, run models with parameter values of their choosing, customize visualizations, and much more. Hadley Wickham from RStudio shows data scientists, data analysts, statisticians, and scientific researchers with no knowledge of HTML, CSS, or JavaScript how to create rich web apps from R. This in-depth guide provides a learning path that you can follow with confidence, as you go from a Shiny beginner to an expert developer who can write large, complex apps that are maintainable and performant. Get started: Discover how the major pieces of a Shiny app fit together Put Shiny in action: Explore Shiny functionality with a focus on code samples, example apps, and useful techniques Master reactivity: Go deep into the theory and practice of reactive programming and examine reactive graph components Apply best practices: Examine useful techniques for making your Shiny apps work well in production

Contents:

Intro

Table of Contents

Preface

What Is Shiny?

Who Should Read This Book?

What Will You Learn?

What Won't You Learn?

Prerequisites

Conventions Used in This Book

Using Code Examples

O'Reilly Online Learning

How to Contact Us

Acknowledgments

How This Book Was Built

Part I. Getting Started

Chapter 1. Your First Shiny App

Introduction

Create App Directory and File

Running and Stopping

Adding UI Controls

Adding Behavior

Reducing Duplication with Reactive Expressions

Summary

Exercises

Chapter 2. Basic UI

Inputs

Common Structure

Free Text

Numeric Inputs

Dates

Limited Choices

File Uploads

Action Buttons

Outputs

Text

Tables

Plots

Downloads

Chapter 3. Basic Reactivity

The Server Function

Input

Output

Reactive Programming

Imperative Versus Declarative Programming

Laziness

The Reactive Graph

Reactive Expressions

Execution Order

The Motivation

The App

Simplifying the Graph

Why Do We Need Reactive Expressions?

Controlling Timing of Evaluation

Timed Invalidation

On Click

Observers

Chapter 4. Case Study: ER Injuries

The Data

Exploration

Prototype

Polish Tables

Rate Versus Count

Narrative

Part II. Shiny in Action

Chapter 5. Workflow

Development Workflow

Creating the App

Seeing Your Changes

Controlling the View

Debugging

Reading Tracebacks

Tracebacks in Shiny

The Interactive Debugger

Case Study

Debugging Reactivity

Getting Help

Reprex Basics

Making a Reprex

Making a Minimal Reprex

Chapter 6. Layout, Themes, HTML

Introduction.

Single-Page Layouts

Page Functions

Page with Sidebar

Multirow

Multipage Layouts

Tabsets

Navlists and Navbars

Bootstrap

Themes

Getting Started

Shiny Themes

Plot Themes

Under the Hood

Chapter 7. Graphics

Interactivity

Basics

Clicking

Other Point Events

Brushing

Modifying the Plot

Interactivity Limitations

Dynamic Height and Width

Images

Chapter 8. User Feedback

Validation

Validating Input

Canceling Execution with req()

req() and Validation

Validate Output

Notifications

Transient Notification

Removing on Completion

Progressive Updates

Progress Bars

Shiny

Waiter

Spinners

Confirming and Undoing

Explicit Confirmation

Undoing an Action

Trash

Chapter 9. Uploads and Downloads

Upload

UI

Server

Uploading Data

Download

Downloading Data

Downloading Reports

Chapter 10. Dynamic UI

Updating Inputs

Simple Uses

Hierarchical Select Boxes

Freezing Reactive Inputs

Circular References

Interrelated Inputs

Dynamic Visibility

Conditional UI

Wizard Interface

Creating UI with Code

Multiple Controls

Dynamic Filtering

Dialog Boxes

Chapter 11. Bookmarking

Basic Idea

Updating the URL

Storing Richer State

Bookmarking Challenges

Chapter 12. Tidy Evaluation

Motivation

Data-Masking

Example: ggplot2

Example: dplyr

User-Supplied Data

Why Not Use Base R?

Tidy-Selection

Indirection

Tidy-Selection and Data-Masking

parse() and eval()

Part III. Mastering Reactivity

Chapter 13. Why Reactivity?

Why Do We Need Reactive Programming?

Why Can't You Use Variables?

What About Functions?

Event-Driven Programming

A Brief History of Reactive Programming

Chapter 14. The Reactive Graph

A Step-by-Step Tour of Reactive Execution

A Session Begins

Execution Begins

Reading a Reactive Expression

Reading an Input

Reactive Expression Completes

Output Completes

The Next Output Executes

Execution Completes, Outputs Flushed

An Input Changes

Invalidating the Inputs

Notifying Dependencies

Removing Relationships

Re-execution

Dynamism

The Reactlog Package

Chapter 15. Reactive Building Blocks

Reactive Values

Errors

on.exit()

Observers and Outputs

Isolating Code

isolate()

observeEvent() and eventReactive()

Polling

Long-Running Reactives

Timer Accuracy

Chapter 16. Escaping the Graph

What Doesn't the Reactive Graph Capture?

Case Studies

One Output Modified by Multiple Inputs

Accumulating Inputs

Pausing Animations

Antipatterns

Part IV. Best Practices

Chapter 17. General Guidelines

Code Organization

Testing

Dependency Management

Source Code Management

Continuous Integration/Deployment

Code Reviews

Chapter 18. Functions

File Organization

UI Functions

Other Applications

Functional Programming

UI as Data

Server Functions

Reading Uploaded Data

Internal Functions

Chapter 19. Shiny Modules

Module Basics

Module UI

Module Server

Updated App

Namespacing

Naming Conventions

Inputs and Outputs.

Getting Started: UI Input and Server Output

Case Study: Selecting a Numeric Variable

Server Inputs

Modules Inside of Modules

Case Study: Histogram

Multiple Outputs

Limited Selection and Other

Wizard

Dynamic UI

Single Object Modules

Chapter 20. Packages

Converting an Existing App

Single File

Module Files

A Package

Benefits

Workflow

Sharing

Extra Steps

Deploying Your App-Package

R CMD check

Chapter 21. Testing

Testing Functions

Basic Structure

Basic Workflow

Key Expectations

User Interface Functions

Code Coverage

Keyboard Shortcuts

Workflow Summary

Testing Reactivity

Modules

Limitations

Testing JavaScript

Basic Operation

Testing Visuals

Philosophy

When Should You Write Tests?

Chapter 22. Security

Data

Compute Resources

Chapter 23. Performance

Dining at Restaurant Shiny

Benchmark

Recording

Replay

Analysis

Profiling

The Flame Graph

Profiling R Code

Profiling a Shiny App

Improve Performance

Caching

Caching a Reactive

Caching Plots

Cache Key

Cache Scope

Other Optimizations

Schedule Data Munging

Manage User Expectations

Index

About the Author

Colophon.

Notes:

Includes index.

Description based on publisher supplied metadata and other sources.

ISBN:

9781492047339

1492047333

9781492047353

149204735X

9781492047377

1492047376

OCLC:

1235778006