Index

Symbols

, (comma)

data frame syntax, 122

function syntax, 69

key-value pair syntax, 191

" (double quotes), character data syntax, 61

' (single quotes), character data syntax, 61

.. (double dot), moving up directory, 14

. (single dot), referencing current folder, 14

| (pipe)

directing output, 20

pipe table, 48

! (exclamation point), Markdown image syntax, 47

# (pound/hashtag symbol)

comment syntax, 10, 58

$ (dollar notation)

accessing data frames, 122

accessing list elements, 97–98

%>% (pipe operator), dplyr package, 141–142

() (parentheses)

function syntax, 70

Markdown hyperlink syntax, 46

* (asterisk wildcard)

loading entire table from database, 173

using wildcards with files, 17–18

? (question mark), query parameter syntax, 184

[] (single-bracket notation)

accessing data frames, 122–123

comparing single- and double-bracket notation, 101

Markdown hyperlink syntax, 46

retrieving value from vector, 88

[[]] (double-bracket notation)

list syntax, 98–99, 101

selecting data of interest for application, 312

{} (braces)

code chunk syntax, 279

key-value pair syntax, 191

render function syntax, 308

<- (assignment operator), 59, 92

>> directing output, 20

> directing output, 20

~ (tilde), home directory shorthand, 10, 15

A

Absolute path

for CSV data, 125

finding R and RScript, 57

for images, 48

specifying paths, 14–15

URLs and, 47

Access tokens (API keys)

example finding Cuban food in Seattle, 196–197

registering with web services, 186–188

add (git). See also Staging Area

add and commit changes, 38–39, 322, 327–328, 333, 337

adding files to repository, 32–33

unadd, 35

aes() function, for aesthetic mappings, 237

Aesthetics

adding titles and labels to charts, 246

aesthetic mappings, 234, 237–238

data visualization, 229–230

Aggregation

proportional representation of data and, 212–213

in Shiny example, 315–316

statistical transformation of data, 255

using summarize(), 138–139

Analysis. See Data analysis

Annotation

capabilities of version control systems, 28

ggplot2 package, 246–248

Anonymous variables, 71, 140

anscombe data set, in R, 208

Anscombe’s Quartet, 208

API keys (Access tokens)

example finding Cuban food in Seattle, 196–197

registering with web services, 186–188

APIs (application programming interfaces). See also Web APIs

defined, 181

in plotly package, 258

Application servers, developing, 306–309

Applications

Shiny app example applying to fatal police shootings, 311–318

structure in Shiny framework, 295–299

app.R file, 295–296

Apps, publishing Shiny, 309–311

Area encoding, visualizing hierarchical data, 218

Arguments

commands and, 13

creating data frames, 120

creating lists, 96

debugging functions, 78

function inputs, 69–70

function parts, 76

named arguments, 72–73

syntax of, 16

vectorized functions and, 87

arrange()

dplyr core functions, 131, 137–138

summarizing information using dplyr functions, 313

Arrays, JSON support, 191–192

AS keyword, renaming columns, 173

Assignment operator (<-)

assigning values to variables, 59

modifying vectors, 92

Atom

preview rendering support, 49–50

selecting text editor, 6–7

writing code, 3

Authentication, API authentication service, 187

B

Bar charts

facets and, 245

position adjustments, 240

proportional representation of data, 211–213

visualizing data with single variable, 210–211

Bash shell. See also Git Bash

commands, 13

executing code, 4

ls command, 13

Bins, breaking data into different variables, 142

BitBucket, comparing with GitHub, 29

Blockquotes, markdown options, 48

Blocks, markdown formatting syntax, 47

Body, function parts, 76–77

Bokeh package, 261

Bold, text formatting, 45–46

Books, resources for learning R, 65

Boolean. See Logical (boolean)

Box plots, 210

Bracket notation

double. See [[]] (double-bracket notation)

retrieving value from vector using bracket notation, 88

single. See [] (single-bracket notation)

Branches

git branching model, 319–320

merging, 324–325

merging from GitHub, 328–329

resolving merge conflicts, 327–328

tracking code versions with, 319–320

using in feature branch workflows, 333–335

using in forking workflows, 335–339

working with, 320–324

working with feature branches, 329–331

C

c() function, creating vectors, 81–82

Case sensitivity, variable names, 58

Categorical data. See Nominal (categorical) data

Causality, assessing statistical relationships, 341

cd, change directory command, 12–13

Centralized workflow

creating centralized repository, 331–333

feature branches in, 333–335

overview of, 331

working with feature branches, 333–335

Character data type

lists and, 95

overview of, 61

vectorized functions and, 87

Charts, 229. See also by individual types of graphs

Cheatsheets

for dplyr, 148

for ggplot2, 255

for GitHub, 43

for markdown, 48

for R functions, 71

for RStudio, 56, 280, 318

checkout (git)

switching between branches, 321–324

working with feature branches, 329–330

working with feature branches in centralized workflow, 335

Checkpoints. See Commit

Choropleth maps

drawing and examples, 248–251

overview of, 248

Chunks

breaking data into different variables, 142

inline code and, 280

options, 279–280

.Rmd files and, 277–278

Circle packing, visualizing hierarchical data, 218–219

clone (git)

collaboration using forking workflow, 336

creating centralized repository, 332

forks, 337

merging branches and, 328

repos, 36–39, 43

understanding/using git commands, 43

Code

chunks, 142, 277–280

executing, 4–5

inline code, 280

managing, 3–4

running, 54–57

syntax-colored code blocks, 48

tracking versions with branches, 319–320

Visual Studio Code (VS Code), 7, 49

writing, 3

Collaboration

centralized workflow for, 331

creating centralized repository, 331–333

interactive web applications and. See Shiny framework

merging branches, 324–325, 328–329

overview of, 273–274, 319

reports. See R Markdown

resolving merge conflicts, 327–328

tracking code versions, 319–320

working with branches, 320–324

working with feature branches, 329–331, 333–335

working with forking workflows, 335–339

collect(), manipulating table data, 177–178

Colon operator (a:b)

creating vectors, 82

specifying range of vector index, 90

Color

adding to Leaflet map, 270

color palettes, 223–225, 242

effective for data visualization, 222–226

ggplot2 color scales, 242–243

ColorBrewer tool

color palettes, 242

examples, 289

overview of, 223–225

colorFactor(), Leaflet maps, 270

Columns

changing to/from rows using tidyr, 157–159

dplyr arrange() operation, 137–138

dplyr filter() operation, 135

dplyr mutate() operation, 136

Columns (fields), in relational databases, 168

Comma-separated value data. See CSV (comma-separated value) data

Command line

accessing, 9–10

changing directories, 12–13

cloning repository, 37

commit history, 320

directing/redirecting output, 20

executing code, 4

handling errors, 18–19

interacting with databases, 31

learning new commands, 16–17

listing files, 13

managing files, 15–16

navigating files, 11–12

networking commands, 20–23

overview of, 9

running R code, 56–57

set up tools, 4–5

specifying paths, 14–15

wildcards, 17–18

working with, 4

Command prompt. See Command line

Command Prompt (Windows)

accessing, 9–10

executing code, 4

working with, 5

Command shell (terminal). See Command line

Commands. See also by individual types

issuing, 13

list of advanced, 18

list of basic, 15

Comments

R language, 58

syntax for code comments, 10

commit (git)

add and commit changes, 33, 38–39, 327–328, 337

creating centralized repository, 333

git core concepts, 28

history, 40

message etiquette, 34–35

reverting to earlier versions, 40–42

tracking code versions, 319–320

understanding/using git commands, 43

working with branches, 320–324

working with feature branches, 330–331, 334

Communities

resources for learning R, 66–67

sources of data, 109

Comparison operators, logical values and, 62

Compiled languages, 53

Complex data type, 63, 99

Comprehensive R Archive (CRAN), 6

Computer, set up, 3–4

Concurrency, capabilities of version control systems, 28

Conditional statements, 79–80

config, configuring git for first-time use, 30

Console, RStudio, 55

Content

building Shiny application, 313

content elements in designing UIs, 299

extracting from HTTP request, 200

static content in Shiny framework, 300–301

content(), extracting content from HTTP request, 200

Continuous color scales, 225–226

Continuous data

choosing effective colors for data visualization, 223

selecting visual layouts, 209–210

visualization with multiple variables, 213–216

visualizing with single variable, 210

Control widgets

developing application servers, 307

in Shiny framework, 295

user interactions in Shiny apps, 301–303

coord_ functions

coord_flip() example, 244

types of coordinate systems for geometric objects, 243–244

Coordinate systems

coord_flip() example, 244

creating choropleth maps, 249–250

creating dot distribution maps, 252

Grammar of Graphics, 232

types for geometric objects, 243–244

cor(), correlation function in R, 161

count(), summarizing information, 313

Courses, resources for learning R, 65–66

CRAN (Comprehensive R Archive), 6

CSS language, 342

CSV (comma-separated value) data

factor variables, 126–129

loading data sets from .csv file, 167

read.csv(), 161

viewing working directory, 125–126

working with, 124–125

ctrl+c, stopping or canceling program or command, 19

D

d3.js JavaScript library, 343

Data

acquiring domain knowledge, 112–113

analyzing. See Data analysis

answering questions, 116–118

dplyr example analyzing flight data, 148–153

dplyr grammar for manipulating, 131–132

encoding, 220–222, 229, 237

finding, 108–109

flattening JSON data, 196–197

generating, 107–108

interactive presentation, 293

interpreting, 112

measuring, 110–111

overview of, 107

ratio data, 111

reusable functions in managing, 70

schemas, 113–116

structures, 111–112, 122

transforming into information, 341

understanding data schemas, 113–116

visualization of. See Data visualization

working with CSV data, 124–125

wrangling, 106

Data analysis

generating data, 108

reusable functions, 70

tidyr package. See tidyr package

Data frames

accessing, 122–123

analyzing by group, 142–144

creating, 120–121

describing structure of, 121–122

factor variables, 126–129

joining, 144–148

overview of, 119–120

viewing working directory, 125–126

working with CSV data, 124–125

data() function, viewing available data sets, 124–125

Data-ink ratio, aesthetics of graphics, 229

Data schemas, 113–116

Data structures

overview of, 111–112

two-dimensional, 122

Data types

factors, 120

lists and, 95

R language, 60–63

selecting visual layouts, 209–210

vectorized functions and, 87

vectorized operations and, 83

Data visualization

aesthetics, 229–230

choosing effective colors, 222–226

choosing effective graphical encodings, 220–222

expressive displays, 227–229

ggplot2. See ggplot2 package

of hierarchical data, 217–220

leveraging preattentive attributes, 226–227

with multiple variables, 213–217

overview of, 205–207

purpose of, 207–209

reusable functions, 70

selecting visual layouts, 209–210

with single variable, 210–213

tidyr package. See tidyr package

Data visualization, interactive

example exploring changes to Seattle, 266–272

leaflet package, 263–266

overview of, 257–258

plotly package, 258–261

rbokeh package, 261–263

Databases

accessing from R, 175–179

designing relational, 144

overview of relational, 167–169

setting up relational, 169–171

SQL statements, 171–175

DataCamp, resources for learning R, 66

dbConnect(), accessing SQLite, 176–177

dbListTables(), listing database tables, 177

dbplyr package, 176–179

dbplyr package, accessing databases, 174

Debugging functions, 78. See also Error handling

Directories

accessing command line and, 10

changing from command line, 12–13

printing working directory, 11

tree structure of, 12

turning into a repository, 31

viewing working directory, 125–126

Displays, expressive, 227–229

Distributions, of x and y values (statistics), 208–209

Documentation

of commands, 16

getting help via, 64

resources for learning R, 66

Shiny layouts, 304

Documents

creating, 275

knitting, 278

Domain, interpreting data by, 112–113

Dot distribution maps, 248, 251–252

Double-bracket notation. See [[]] (double-bracket notation)

dplyr package

analyzing data frames, 142–144

analyzing flight data, 148–153

arrange(), 137–138

converting dplyr functions into SQL statements, 178

core functions, 131–132

example mapping evictions in San Francisco, 252

example report on life expectancy, 289

filter(), 135–136

grammar for data manipulation, 131–132

group_by(), 244

joining data frames, 144–148

mutate(), 136–137

orienting data frames for plotting, 239

overview of, 131

performing sequential operations, 139–141

pipe operator (%>%), 141–142

select(), 133–134

summarize(), 138–139

Dynamic inputs, Shiny framework, 301–303

Dynamic outputs, Shiny framework, 303–304

Dynamically typed languages, 60

E

Encoding data

aesthetic graphics, 229

aesthetic mappings, 237

choosing effective graphical encodings, 220–222

Endpoints, web APIs, 183–185

Environment pane, RStudio, 55

Error handling

command line, 18–19

debugging functions, 78

reading error messages, 63

Ethical responsibilities, 343

Excel, working with CSV data, 124

exit

disconnecting from remote computer, 22

stopping or canceling program or running command, 19

Expressions, multiple operators in, 61

Extensions, file, 6, 48–49

F

facet_ functions, 244–245

Facets

ggplot2 package, 244–245

Grammar of Graphics, 232

Factors

creating data frames, 120

variables, 126–129

Feature branches

in centralized workflow, 333–335

working with, 329–331

Fields (columns), in relational databases, 168

figure(), creating Bokeh plots, 262–263

Files

adding to repository, 32–33

changing directories, 12–13

creating .Rmd files, 276–278

extensions, 6, 48–49

ignoring, 42–44

listing, 13

managing, 15–16

navigating, 11–12

specifying paths, 14–15

fill(), aesthetic layouts, 238–240

filter()

dplyr core functions, 131, 135–136

example report on life expectancy, 289

manipulating table data, 177–178

Filtering

joins, 148

vectors, 90–91, 93

flatten()

example finding Cuban food in Seattle, 200, 202

JSON data, 196–197

for loops, 87

Foreign keys, in relational databases, 168–169

fork, repos on GitHub, 36–38

Forking workflow

feature branches in, 331, 333–335

working with, 335–339

Formats

table, 157

text, 46

Formulas, 245

Frameworks

defined, 293

Shiny framework. See Shiny framework

fromJSON(), converting JSON string to list, 193–194, 200

full_join(), 148

function keyword, 76

Functions

for aesthetic mappings (aes()), 237–238

applying to lists, 102–103

built-in, 71–72

c() function, 81–82

conditional statements, 79–80

converting dplyr functions into SQL statements, 178

coord_ functions, 243–244

correlation function (cor()), 161

creating lists, 96

debugging, 78. See also Error handling

developing application servers, 307–309

geometry. See geom_ functions

inspecting data frames, 121–122

loading, 73–75

named arguments, 72–73

nested statements within, 140–141

overview of, 69–70

referencing database table, 177

in Shiny layouts, 305

syntax, 70–71

tidyr functions for changing columns to/from rows, 157–159

vectorized, 86–88

viewing available data sets (data()), 124–125

writing, 75–77

Functions, dplyr

arrange(), 137–138

core functions, 131–132

filter(), 135–136

group_by(), 142–144

left_join(), 145–147

mutate(), 136–137

overview of, 132

select(), 133–134

summarize(), 138–139

summarizing information using, 313

G

gather()

applying to educational statistics, 161–163

combining with spread(), 159

tidyr function for changing columns to rows, 157–158

geom_ functions

adding titles and labels to charts, 247–248

aesthetic mappings and, 237–238

creating choropleth maps, 249–250

creating dot distribution maps, 252

example mapping evictions in San Francisco, 253–256

rendering plots, 284

specifying geometric objects, 234

specifying geometries, 235–237

statistical transformation of data, 237

Geometries

ggplot2 layers, 232

position adjustments, 238–240

specifying geometric objects, 234–235

specifying with ggplot2 package, 235–237

GET

example finding Cuban food in Seattle, 197–198, 202

HTTP verbs, 188–189

sending GET requests, 189–190

getwd(), viewing working directory, 125

ggmap package

example finding Cuban food in Seattle, 200–203

example mapping evictions in San Francisco, 253

map tiles, 252

ggplot()

creating plots, 232, 234

example mapping evictions in San Francisco, 256

ggplot2 package

aesthetic mappings, 237–238

basic plotting, 232–235

choropleth maps, 248–251

coordinate systems, 243–244

dot distribution maps, 252

example finding Cuban food in Seattle, 200

example mapping evictions in San Francisco, 252–256

facets, 244–245 Grammar of Graphics, 231–232

labels and annotations, 246–248

map types, 248

position adjustments, 238–240

rendering plots, 284

specifying geometries, 235–237

static plot of iris data set, 257–258

statistical transformation of data, 255

styling with scales, 240–242 tidyr example, 160–161

ggplotly(), 259

ggrepel package, preventing labels from overlapping, 247–248

git

accessing project history, 40–42

adding files, 32–33

branching model. See Branches

checking repository status, 31–33

committing changes, 33–35

core concepts, 27–28

creating repository, 30–31

ignoring files, 42–44

installing, 5

leveraging using GitHub, 6

local git process, 35

managing code with, 3–4

overview of, 27–28

project setup and configuration, 30

tracking changes, 32

tutorials, 43–44

version control, 4

Git Bash. See also Bash shell

accessing command line, 9–10

commands used by, 13

executing code using Bash shell, 4–5

ls command, 13

tab-completion support, 15

Git Flow model, 335

GitHub

accessing project history, 40–42

creating centralized repository, 331–333

creating GitHub account, 6

forking/cloning repos on GitHub, 36–38

ignoring files, 42–44

managing code with, 3

overview of, 29

pushing/pulling repos on GitHub, 38–40

README file, 48–49

sharing reports as website, 285–286

storing projects on, 36

tutorials, 43–44

.gitignore, ignoring files, 42–44

GitLab, comparing with GitHub, 29

Google Docs, version control systems compared with, 28

Google, getting help via, 63

Google Sheets, working with CSV data, 124

Government publications, sources of data, 108

Grammar of Data Manipulation (Wickham), 131

Grammar of Graphics, 231–232

Graphics. See also by individual types of graphs; Data visualization

aesthetics, 229–230

choosing effective graphical encodings, 220–222

expressive displays, 227–229

with ggplot2. See ggplot2 package Grammar of Graphics, 231–232

leveraging preattentive attributes, 226–227

selecting visual layouts, 209–210

visualizing hierarchical data, 217–220

group_by()

analyzing data frames by group, 142–144

facets and, 244

statistical transformation of data, 255

summarizing information using, 313

GROUP_BY clause, SQL SELECT, 174

H

Heatmaps. See also Choropleth maps

data visualization with multiple variables, 215, 217

example mapping evictions in San Francisco, 256

Help

R language, 63–64

RStudio, 55

Hidden files, 42–44

Hierarchical data, visualization of, 217–220

Histograms

data visualization with multiple variables, 216

expressive displays, 229

visualizing data with single variable, 210

Hosts, Shiny apps, 309–310

HSL Calculator, 223

HSL (hue-saturation-lightness) color model, 222–223

HTML (Hypertext Markup Language)

HTML Tags Glossary, 300–301

markup languages, 45

sharing reports as website, 284–286

web development language, 342

HTTP (HyperText Transfer Protocol)

header, 196–197

overview of, 181–182

verbs, 188–189

HTTP requests

example finding Cuban food in Seattle, 196–200

response header and body, 190

web services and, 181

HTTP verbs, Web APIs, 188–189

httr package

parsing JSON data, 192–193

sending GET requests, 189–190

Hue

choosing effective colors for data visualization, 222

multi-hue color scales, 225

Hue-saturation-lightness (HSL) color model, 222–223

Hyperlinks, markdown, 46–47

I

Icons, types of interfaces, 9

IDE (integrated development environment), 54

if_else, conditional statements, 79–80

Images, markdown, 47–48

Indices

for getting subsets of vectors, 88–89

multiple indices, 89–90

init (git), turning a directory into a git repository, 31

Inline code, in R Markdown, 280

INNER JOIN clause, SQL

SELECT, 174

inner_join(), 147–148

Inputs

dynamic inputs with Shiny framework, 301–303

functions and, 69

Shiny framework, 293–294

Integer data type, 63

Integrated development environment (IDE), 54

Interactivity

interactive data visualization. See Data visualization, interactive

interactive web applications. See Shiny framework

Interface

command line as, 9

defined, 181

user. See UIs (user interfaces)

web APIs. See Web APIs

Interpreted languages, 53

Interval data, measuring data, 111

iris data set, interactive plots in, 257–258

Italics, text formatting, 45–46

J

JavaScript, 342–343

join()

dplyr core functions, 131

joining data frames, 144–148

JOIN clause, SQL SELECT, 174–175

Journalism, sources of data, 109

JSON (JavaScript Object Notation)

flattening JSON data, 195–197

list of lists structure in, 97

parsing JSON data, 193–195

processing JSON data, 191–193

jsonlite package, 192–193

K

kable(), knitr package, 283–284, 291

Key-value pairs

JSON (JavaScript Object Notation), 191

query parameters and, 184

tidyr data tables, 157

knitr package

creating R Markdown documents, 275

kable(), 283–284, 291

Knitting documents, 278

L

Labels

adding to plots, 246–248

aesthetics of graphics, 230

labs(), adding titles and labels to charts, 246

lapply(), applying functions to lists, 102–103

Layers, ggplot2 package, 232

layout(), 260–261, 268

Layouts

coordinate systems, 243–244

designing UIs, 299

example exploring changes to Seattle, 268

facets, 244–245

labels and annotations, 246–248 plotly package, 260–261

position adjustments, 238–240

selecting visual, 209–210

Shiny framework, 304–306

styling with scales, 240–242

Lazy evaluation, in dplyr package, 178

leaflet()

creating Leaflet map, 264

example exploring changes to Seattle, 269

leaflet package

creating interactive plots, 264–266

example exploring changes to Seattle, 269–271

installing and loading, 263

Shiny app example applying to fatal police shootings, 312–313

Learn Git Branching, 339

LEFT JOIN clause, SQL

SELECT, 174

left_join()

example of join operation, 145–146

join types, 146–147

Legends

adding to Leaflet map, 270–271

aesthetics of graphics, 230

length() function, determining number of elements in a vector, 82

Libraries. See Packages

library(), referencing external packages, 311

Lightness, choosing effective colors for data visualization, 223

Linux

command-line tools on, 5

installing git, 5

list() function, creating lists, 96

Lists

accessing elements of, 97–99

applying functions to, 102–103

converting JSON string to list, 193–194

creating, 96–97

creating data frames, 120–121

double-bracket notation, 101

JSON structures compared with, 192–193

listing files from command line, 13

modifying, 100

overview of, 95

rendering Markdown lists, 282–283

log, viewing commit history, 40

Logical (boolean)

data type, 61–63

debugging functions, 78

operators, 62–63

vector filtering by values, 90–91

Loops, vectorized functions and, 87

ls

list folder contents, 13

using with remote computer, 22

M

-m option, adding messages to commit command, 34

Mac OSs. See also Terminal (Mac)

accessing command line, 9–10

command-line tools on, 4

installing git, 5

Machine learning, making predictions, 342

Mackinlay’s Expressiveness Criteria, 227–229

man, looking up commands in manual, 16–17

Map tiles

adding to Leaflet map, 264

ggmap package, 252

Maps

aesthetic mappings, 237–238

choropleth maps, 248–251

dot distribution maps, 251–252

example mapping evictions in San Francisco, 252–256

interactive, 263

types of, 248

Markdown

hyperlinks, 46–47

images, 47–48

overview of, 45

rendering, 48–50

rendering lists, 282–283

rendering strings, 281

rendering tables, 283–284

static content elements of UIs, 300–301

tables, 48

text formatting and blocks, 46

Markdown Reader, 49

Markers, adding to Leaflet map, 264

Markup languages, 45

Mathematical operators

applying to vectors, 83

assigning values to variables, 59

using on numeric data types, 60

vectorized functions and, 86–87

Matrix, two-dimensional data structures in

R, 122

.md file extension, for markdown files, 48

Menus, types of interfaces, 9

merge (git)

combining branches, 324–325

forking/cloning repository on GitHub, 337–338

resolving merge conflicts, 327–328

working with feature branches, 330, 334–335

Merging, git core concepts, 29

message etiquette,

commit, 34–35

Meta-data, 114–116, 277

Microsoft Excel, 124

Microsoft Windows. See Windows OSs

mkdir, documentation of commands, 16–17

Moral responsibility, 343

mutate()

dplyr core functions, 131, 136–137

example finding Cuban food in Seattle, 202

example report on life expectancy, 289–290

Mutating joins, 148

MySQL, 171

N

NA value

compared with NULL, 100

logical values and, 89

modifying vectors and, 92

Named arguments,

R functions, 72–73

Named lists, creating data frames, 120

names() function, creating lists and, 96

Negative index, vector indices, 89

Nested objects, JSON support, 192

Nested statements, within other functions, 140–141

Nested structures, visualizing hierarchical data, 217–220

Networking commands, 20–23

News, sources of data, 109

Nominal (categorical) data

choosing effective colors for data visualization, 223

data visualization with multiple variables, 215

measuring data, 110

proportional representation of data and, 212

selecting visual layouts and, 209–210

visualizing single variable, 210

Non-standard evaluation (NSE), dplyr, 133

NULL value, modifying lists and, 100

Numbers, working with CSV data, 124

Numeric data type, 60–61, 95

O

OAuth, API authentication service, 187

Observations, data structures, 111–112

ON clause, SQL

SELECT, 174

Online communities, sources of data, 109

Open source,

R language as, 53

OpenStreetMap, 264

Operationalization, using data to answer questions, 116–118

Optional arguments, functions and, 72

Options (flags), argument syntax, 16

OPTIONS, HTTP verbs, 188

ORDER_BY clause, SQL SELECT, 174

Ordinal data

measuring data, 110–111

selecting visual layouts and, 209–210

Orientation, tidyr data tables, 157

Out-of-bounds indices, vector indices, 89

OUTER JOIN clause, SQL

SELECT, 174

Outliers, visualizing data with single variable, 210

Output

directing/redirecting, 20

dynamic, 303–304

functions and, 69

reactive, 295

Shiny framework, 293–294

P

Packages

Bokeh, 261

dbplyr, 176–179

dplyr. See dplyr package

ggmap. See ggmap package

ggplot2. See ggplot2 package

ggrepel, 247–248

httr, 189–190, 192–193

jsonlite, 192–193

knitr. See knitr package

leaflet. See leaflet package

plotly, 258–261

of R functions, 73–75

rbokeh, 261–263

RColorBrewer, 224–225

referencing external, 311

rmarkdown, 275

RStudio, 55

tidyr. See tidyr package

tidyverse, 132, 142

Panning, interactive data visualization, 257

Parameters

function inputs, 69–70

query parameters, 184–186, 202

Passing arguments

debugging functions, 78

to functions, 70

PATCH, HTTP verbs, 188

Paths

finding, 57

on remote computers, 22

specifying from command line, 14–15

viewing working directory, 125

Pie charts, 211–213, 221

pipe operator (%>%), dplyr package, 141–142

pipe table, 48

plot_ly()

creating plots, 260

example exploring changes to Seattle, 268

plotly package

creating interactive plots, 259–261

example exploring changes to Seattle, 268

loading, 258

Plots

ggplot2 package. See ggplot2 package

plotly package. See plotly package

plotting, 232–235

rendering in R Markdown, 284

RStudio, 55

Pointers, types of interfaces, 9

Popups, adding interactivity to Leaflet map, 266

Positional arguments

functions and, 72–73

ggplot2 geometries, 238–240

PostgreSQL, 170–171, 176

Powershell, Windows Management Framework, 5

Preattentive processing, in data visualization, 226–227

Predictions, 342

Preview Markdown rendering, 49

Primary keys, in relational databases, 168–169

print(), analyzing flight data, 152

Probability, 342. See also Statistics Problem domain, interpreting data by domain, 112–113

Programming/programming languages

compiled languages, 53

data wrangling, 106

dynamically vs. statically typed languages, 60

interpreted languages, 53

learning, 342–343

markup languages, 45

R language. See R language

S language, 53

SQL. See SQL (Structured Query Language)

statically typed, 60

statistical languages, 53

Proportional representation, visualizing data with single variable, 211–212

publishing apps, Shiny framework, 309–311

pull (git)

creating centralized repository, 333

merging from GitHub, 328

repos on GitHub, 38–40

understanding/using git commands, 43

working with feature branches, 335

Pull request, GitHub, 335–339

push (git)

creating centralized repository, 333

merging from GitHub, 328–329

repos on GitHub, 38–40

understanding/using git commands, 43

working with feature branches, 333–335

pwd, print working directory, 11, 22

Python, 342

Q

qmplot(), creating background maps, 253–254

Query parameters

example finding Cuban food in Seattle, 202

in Web URIs, 184–186

quit (q), stopping or canceling program or running command, 19

R

R for Everyone, 341

R language

accessing databases, 175–179

accessing Web APIs, 189–190 anscombe data set in, 208

arguments, 72–73

built-in functions, 71–72

code chunks and, 279–280

comments, 58

data types, 60–63

downloading, 6–8

as dynamically typed language, 60

function packages, 73–75

function syntax, 70–71

functions in Shiny layouts, 305

help resources, 63–64

interactive data visualization. See Data visualization, interactive learning, 64–67

overview of, 4

programming with, 53–54

running R code from command line, 56–57

running R code using RStudio, 54–56

two-dimensional data structures, 122

variable definition, 58–60

web application framework. See Shiny framework

R Markdown

code chunks and, 279–280

creating .Rmd files, 276–278

example report on life expectancy, 287–292

inline code and, 280

knitting documents, 278

rendering lists, 282–283

rendering plots, 284

rendering strings, 281–282

rendering tables, 283–284

setting up reports, 275

sharing reports, 284–286

static content elements of UIs, 300–301

Ratio data, measuring, 111

rbokeh package

creating interactive plots, 262–263

installing and loading, 261–262

RColorBrewer package, 224–225

RDMS (relational database management system), 169. See also Relational databases

Reactive output

dynamic outputs with Shiny framework, 303–304

render functions and, 308

in Shiny framework, 295

Reactivity, in Shiny framework, 295

read.csv()

creating choropleth maps, 250

example mapping evictions in San Francisco, 253

in R, 161

README file, GitHub, 48–49

Records

data structures, 111–112

keeping, 107–108

Recycling operation, vectors, 84–85

Redirects, output, 20

Relational databases

accessing, 175–179

designing, 144

overview of, 167–169

setting up, 169–171

SQL statements, 171–175

Relational operators

logical values and, 62

vector filtering with, 91

Relationships

assessing in statistical learning, 341–342

between x and y values (statistics), 208–209

Relative path

images, 48

specifying paths, 14

URLs, 47

viewing working directory, 125–126

Remote repository

git core concepts, 29

repositories as remotes, 36

Remote computers, accessing, 20–21

Render function

developing application servers, 307–309

in Shiny framework, 295–296

Rendering markdown, 48–50

Reports, 275. See also R Markdown

Repository (repo)

checking status, 31–33

creating, 30–31

creating centralized repository, 331–333

forking/cloning on GitHub, 36–38, 336–337 git core concepts, 28

linking online to local, 36

pushing/pulling on GitHub, 38–40

viewing current branch, 320–321

REpresentational State Transfer. See REST (REpresentational State Transfer)

Required arguments, functions and, 72

Research, sources of data, 109

reset, destroying

commit history, 42

Response body, HTTP requests, 190

Response header, HTTP requests, 190

REST (REpresentational State Transfer)

responding to HTTP requests, 189

web APIs, 182

web services and, 181

Return value

c() function, 81–82

function parts, 77

writing functions, 75–76

Reversibility

capabilities of version control systems, 28

reverting to earlier versions, 40–42

revert, reverting to earlier versions, 40–42

RIGHT JOIN clause, SQL

SELECT, 174

right_join(), 145–147

rmarkdown package, creating R Markdown documents, 275

.Rmd files, creating, 276–278

round() function, vectorized functions and, 86–87

Rows

arrange() operation, 137–138

changing from columns to/from, 157–159

filter() operation, 135

Rows (records), in relational databases, 168

RScript, running scripts from command line, 57

RStudio

changing working directory, 125

cheatsheet, 56, 280, 318

creating list elements, 97

creating .Rmd files, 276–278

debugging functions, 78

downloading, 8

getting help via RStudio community, 64

ggplot2 graphics in RStudio window, 233

knitting documents, 278

running R code, 54–56

running Shiny apps, 297–298

writing code with, 3

rworldmap, example report on life expectancy, 289, 291

S

sapply(), applying functions to lists, 103

Saturation, choosing effective colors for data visualization, 222

Scalable vector graphics (SVGs), 266

Scalar, example adding, 85–86

Scale, ggplot2

color scales, 242–243

styling with, 240–241

Scatterplot matrix, 213

Scatterplots

Anscombe’s Quartet, 209

data visualization with multiple variables, 213–217

ggplot2 example, 233

Scientific research, sources of data, 109

Scripts

programming with R language, 53–54

running from command line, 57

running using RStudio, 54

select()

dplyr core functions, 131, 133–134

example report on life expectancy, 289–290

manipulating table data, 177–178

SELECT statement

ON clause, 174

JOIN clause, 174–175

ORDER_BY and GROUP_BY clauses, 174

SQL statements, 171–174

WHERE clause, 173–174

Sensors, generating data, 107

seq() function, creating vectors and, 82–83

Sequences, performing sequential operations, 139–141

Servers

application structure in Shiny framework, 296

building Shiny application, 313–318

defined, 294

developing application servers, 306–309

division of responsibility in Shiny apps, 298–299

Shapefiles, creating choropleth maps, 248–249

Shapes, adding to Leaflet map, 264

Sharing. See Collaboration

Shiny framework

application structure, 295–299

core concepts, 294–295

designing user interfaces, 299

developing application servers, 306–309

dynamic inputs, 301–303

dynamic outputs, 303–304

example applying to fatal police shootings, 311–318

layouts, 304–306

overview of, 293–294

publishing Shiny apps, 309–311

static content, 300–301

shinyApp(), 296–297, 299

shinyapp.io, hosting Shiny apps, 309–310

Sidebar, in Shiny example, 316

Single-bracket notation. See [] (single-bracket notation)

Slideshows, 275

snake_case

variable names, 58

writing functions, 76

Snapshots. See Commit

source(), loading and running API keys, 188

spread()

applying to educational statistics, 164–165

changing rows to columns, 158–159

Spreadsheets, working with CSV data, 124

SQL (Structured Query Language)

converting dplyr functions into SQL equivalents, 178

JOIN clause, 174–175

ORDER_BY and GROUP_BY clauses, 174

resources for learning, 171

SELECT statement, 171–173

WHERE clause, 173–174

SQLite

accessing from R, 176–177

SELECT statement in, 172

types of RDMSs, 169–170

WHERE clause, 173–174

ssh, accessing remote computers, 21–22

Stacked bar charts, 211–213, 239

StackOverflow, getting help via, 64

Staging area, adding files, 33. See also add (git)

Statements

conditional, 79–80

SQL, 171–175

Static content

building Shiny application, 313

Shiny framework, 300–301

Statically typed language, 60

Statistical learning

assessing relationships, 341–342

making predictions, 342

overview of, 341

Statistics

Anscombe’s Quartet, 208–209

applying tidyr to educational statistics, 160–165

statistical transformation of data, 237, 255

status (git)

checking project status, 323

checking repository status, 31–33

pushing branches to GitHub, 329

resolving merge conflicts, 327–328

understanding/using git commands, 43

Strings

character data types, 61

rendering in R Markdown, 281–282

Style, vs. syntax, 59

Sublime Text, selecting text editor, 7

Subplots, facets and, 244

Subset, of vector, 88–89

summarize(), dplyr core functions, 131, 138–139

Sunburst diagrams, 218, 220

Surveys, generating data, 107

SVGs (scalable vector graphics), 266

Syntax

debugging functions, 78

vs. style, 59

Syntax-colored code blocks, markdown options, 48

T

Tab-completion, command shells supporting, 15

Tables

building Shiny application, 314–318

creating data frames, 120

data structures, 111–112 JOIN clause, 174

markdown, 48

referencing database table, 177

in relational databases, 168

rendering, 283–284

tidyr, 157

Tagged elements, in lists, 95–96

tbl(), referencing database table, 177

Terminal (command shell). See Command line

Terminal (Linux), 5

Terminal (Mac)

accessing, 9–10

connecting to remote server, 21

executing code, 4 ls command, 13

manuals (man pages), 17

running R code, 56–57

setting up, 4

tab-completion support, 15

Text blocks, markdown, 46

Text editor, 6–7

Text formatting, 46

theme(), creating choropleth maps, 251

Tibble data frame, 142–143

tidyr package

applying to educational statistics, 160–165

changing from columns to/from rows, 157–159

example mapping evictions in San Francisco, 252

orienting data frames for plotting, 239

overview of, 155–157

reshaping data sets, 165

The tidyverse style guide

defining variables, 58 dplyr package, 132

tibble data frame, 142–143

writing functions, 76

Treemaps, 211–213, 218–220

Tutorials, for learning R, 65–66

U

UIs (user interfaces)

application structure in Shiny framework, 295–296

building Shiny application, 313–318

defined, 294

designing, 299

division of responsibility in Shiny apps, 298–299

Unit of analysis, grouping for redefining, 144

Unordered lists, rendering Markdown lists, 282–283

URIs (Uniform Resource Identifiers)

example finding Cuban food in Seattle, 202

HTTP requests and, 182–184

hyperlink syntax, 46–47

URLs (Uniform Resource Locators), 182, 286

User interfaces. See UIs (user interfaces)

Users, accessing command line, 10

V

Values

creating vectors, 81–82

modifying vectors, 92–93

tidyr cells representing, 155

vectors as one-dimensional collections of, 81

Variables

anonymous, 71, 140

breaking data into, 142

creating intermediary variables for use in analysis, 139

data visualization with multiple, 213–217

data visualization with single, 210–213

defining, 58–60

factor variables, 126–129

storing Shiny layouts in, 305

tidyr columns representing, 155

VCS (version control system), 28

Vectorized functions, 86–88

Vectors

creating, 81–83

creating data frames, 120

example adding, 85–86

filtering, 90–91

lists and, 95

modifying, 92–93

multiple indices, 89–90

overview of, 81

performing operations on, 83–84

recycling operation, 84–85

subsets of, 88–89

vectorized functions, 86–88

Verbs

dplyr package, 131

HTTP verbs, 188–189

Version control

accessing project history, 40–42

adding files, 32–33

checking repository status, 31–33

command line in, 9

committing changes, 33–35

creating repository, 30–31

forking/cloning repos and, 36–38

git for, 4, 27–29

GitHub for, 29

ignoring files, 42–44

local git process, 35

overview of, 27

project setup and configuration, 30

pushing/pulling repos and, 38–40

storing projects on GitHub, 36

tracking changes, 32, 319–320

Version control system (VCS), 28

Videos, resources for learning R, 65

Violin plots

data visualization with multiple variables, 215

data visualization with single variable, 210

Visual channels, aesthetic mappings and, 237

Visual storytelling with D3, 343

Visualization. See Data visualization

VS Code (Visual Studio Code)

preview rendering support, 49

selecting text editor, 7

W

Web APIs

access tokens (API keys), 186–188, 196–197

accessing from R, 189–190

example locating Cuban food in Seattle, 197–203

flattening JSON data, 195–197

HTTP verbs, 188–189

overview of, 181–182

parsing JSON data, 193–195

processing JSON data, 191–193

query parameters, 184–186

RESTful requests, 182

URIs and, 182–184

Web applications

defined, 293

interactive. See Shiny framework

Web browsers, Shiny framework as interface, 293–294

Web servers, 182. See also Servers

Web services. See also Web APIs

overview of, 181

registering with, 186–188

Webpage, URL for, 286

Websites

creating using R Markdown, 275

publishing Shiny apps, 309–311

sharing R Markdown reports, 284–286

WHERE clause,

SELECT statement, 173–174

Widgets. See Control widgets

Wildcards, command line, 17–18

Windows, icons, menus, and pointers (WIMP), 9

Windows Management Framework, 5

Windows OSs

accessing command line, 9–10

command-line tools, 4–5

installing git, 5

Windows, types of interfaces, 9

Workflows

centralized, 331

creating centralized repository, 331–333

tracking code versions with branches, 319–320

working with feature branch workflows, 333–335

working with forking workflows, 335–339

X

Xcode command line developer tools, 5

Z

Zooming, interactive data visualization, 257