Appendix A: Packages used
A.1 ambient
Package Profile: ambient
Generation of natural looking noise has many application within simulation, procedural generation, and art, to name a few. The {ambient} package provides an interface to the ‘FastNoise’ C++ library and allows for efficient generation of perlin, simplex, worley, cubic, value, and white noise with optional perturbation in either 2, 3, or 4 (in case of simplex and white noise) dimensions.
A.2 bslib
Package Profile: bslib
Simplifies custom ‘CSS’ styling of both ‘shiny’ and ‘rmarkdown’ via ‘Bootstrap’ ‘Sass’. Supports ‘Bootstrap’ 3, 4 and 5 as well as their various ‘Bootswatch’ themes. An interactive widget is also provided for previewing themes in real time.
A.3 callr
Package Profile: callr
It is sometimes useful to perform a computation in a separate R process, without affecting the current R process at all. This packages does exactly that.
A.4 dplyr
Package Profile: dplyr
{dplyr} is a grammar of data manipulation, providing a consistent set of verbs that help you solve the most common data manipulation challenges: - mutate() adds new variables that are functions of existing variables - select() picks variables based on their names. - filter() picks cases based on their values. - summarise() reduces multiple values down to a single summary. - arrange() changes the ordering of the rows.
These all combine naturally with group_by() which allows you to perform any operation “by group”. You can learn more about them in vignette(“dplyr”). As well as these single-table verbs, dplyr also provides a variety of two-table verbs, which you can learn about in vignette(“two-table”). (Wickham et al. 2023)
A.5 DT
Package Profile: DT
Data objects in R can be rendered as HTML tables using the JavaScript library ‘DataTables’ (typically via R Markdown or Shiny). The ‘DataTables’ library has been included in this R package. The package name ‘DT’ is an abbreviation of ‘DataTables’.
A.6 forcats
Package Profile: forcats
Provides tools for working with categorical variables, also known as factors. It offers functions for reordering factor levels, such as moving specified levels to the front, ordering by first appearance, reversing, and randomly shuffling. Additionally, it includes tools for modifying factor levels, including collapsing rare levels into a single category, anonymizing, and manually recoding. “Forcats” is an anagram of “factors” and part of the {tidyverse} suite of packages.
A.7 ggplot2
Package Profile: ggplot2
{ggplot2} is a system for declaratively’ creating graphics, based on “The Grammar of Graphics” (Wilkinson et al. 2005) — a general scheme for data visualization which breaks up graphs into semantic components such as scales and layers. It allows users to create graphs from composable elements instead of being limited to a predefined set of charts. You provide the data, tell {ggplot2} how to map variables to aesthetics, what graphical primitives to use, and it takes care of the details.
A.8 glossary
Package Profile: glossary
Add glossaries to markdown and quarto documents by tagging individual words. Definitions can be provided inline or in a separate file. The goal of this glossary is to provide a lightweight solution for making glossaries in educational materials written in quarto or R Markdown.
A.9 glue
Package Profile: glue
An implementation of interpreted string literals, inspired by Python’s Literal String Interpolation. Glue offers interpreted string literals that are small, fast, and dependency-free. Glue does this by embedding R expressions in curly braces which are then evaluated and inserted into the argument string.
A.10 htmltools
Package Profile: htmltools
Tools for HTML generation and output. {htmltools} makes it easy to customize the user interface (UI) of any Shiny or R Markdown project by using R code to generate custom HTML (including JavaScript and CSS).
A.11 janitor
Package Profile: janitor
The main janitor functions can: perfectly format data.frame column names; provide quick counts of variable combinations (i.e., frequency tables and crosstabs); and explore duplicate records. Other janitor functions nicely format the tabulation results.
These tabulate-and-report functions approximate popular features of SPSS and Microsoft Excel. This package follows the principles of the “tidyverse” and works well with the pipe function %>%. janitor was built with beginning-to-intermediate R users in mind and is optimized for user-friendliness.
A.12 knitr
Package Profile: knitr
Provides a general-purpose tool for dynamic report generation in R using Literate Programming techniques. a general-purpose tool for dynamic report generation in R using Literate Programming techniques. It allows integrating R code into various document formats such as LaTeX, LyX, HTML, Markdown, AsciiDoc, and reStructuredText and especially R Markdown and Quarto. The package enables reproducible research by allowing users to combine code, results, and narrative text in a single document. It supports multiple output formats including PDF, HTML, Word, and more.
A.13 lattice
Package Profile: lattice
An implementation of Trellis graphics for R. It is a powerful and elegant high-level data visualization system with an emphasis on multivariate data. It is designed to meet most typical graphics needs with minimal tuning, but can also be easily extended to handle most nonstandard requirements.
A.14 leaflet
Package Profile: leaflet
powerful tool for creating interactive web maps in R. It serves as an interface to the popular open-source JavaScript library Leaflet, which is widely used for building dynamic and mobile-friendly maps. The leaflet R package allows users to leverage the capabilities of Leaflet directly from R, making it accessible for data scientists, analysts, and researchers who want to visualize spatial data interactively.
A.15 plotly
Package Profile: plotly
Create interactive web graphics from ‘ggplot2’ graphs and/or a custom interface to the (MIT-licensed) JavaScript library ‘plotly.js’ inspired by the grammar of graphics.
Plotly.js is a standalone Javascript data visualization library, and it also powers the Python and R modules named plotly in those respective ecosystems (referred to as Plotly.py and Plotly.R).
Plotly.js can be used to produce dozens of chart types and visualizations, including statistical charts, 3D graphs, scientific charts, SVG and tile maps, financial charts and more.
A.16 progress
Package Profile: progress
Configurable Progress bars, they may include percentage, elapsed time, and/or the estimated completion time. They work in terminals, in ‘Emacs’ ‘ESS’, ‘RStudio’, ‘Windows’ ‘Rgui’ and the ‘macOS’ ‘R.app’. The package also provides a ‘C++’ ‘API’, that works with or without ‘Rcpp’.
A.17 purrr
Package Profile: purrr
{purrr} enhances R’s functional programming (FP) toolkit by providing a complete and consistent set of tools for working with functions and vectors. It offers a family of map() functions that allow users to replace many for loops with more succinct and readable code. The package is part of the tidyverse and is designed to work naturally with the pipe operator.
If you’ve never heard of FP before, the best place to start is the family of purrr::map() functions which allow you to replace many for loops with code that is both more succinct and easier to read. The best place to learn about the purrr::map() functions is the iteration chapter in R for data science.
A.18 ragg
Package Profile: ragg
Anti-Grain Geometry (AGG) is a high-quality and high-performance 2D drawing library. The ‘ragg’ package provides a set of graphic devices based on AGG to use as alternative to the raster devices provided through the ‘grDevices’ package
A.19 reactable
Package Profile: reactable
An interactive data table library that allows users to create dynamic and customizable tables in R. It is based on the “React Table” JavaScript library and provides an HTML widget that can be used in R Markdown documents, Shiny applications, or viewed directly from an R console.
The package offers features such as sorting, pagination, filtering, and searching, making it suitable for data exploration and visualization. The main function of the package is reactable(), which takes a data frame as input and returns an interactive table.
A.20 reactlog
Package Profile: reactlog
Building interactive web applications with R is incredibly easy with ‘shiny’. Behind the scenes, ‘shiny’ builds a reactive graph that can quickly become intertwined and difficult to debug. ‘reactlog’ provides a visual insight into that black box of ‘shiny’ reactivity by constructing a directed dependency graph of the application’s reactive state at any time point in a reactive recording
A.21 readr
Package Profile: readr
The goal of readr is to provide a fast and friendly way to read rectangular data from delimited files, such as comma-separated values (CSV) and tab-separated values (TSV). It is designed to parse many types of data found in the wild, while providing an informative problem report when parsing leads to unexpected results. (Wickham, Hester, and Bryan 2024)
{readr} supports the following formats:
- read_csv(): comma-separated values (CSV)
- read_tsv(): tab-separated values (TSV)
- read_csv2(): semicolon-separated values with , as the decimal mark
- read_delim(): delimited files (CSV and TSV are important special cases)
- read_fwf(): fixed-width files
- read_table(): whitespace-separated files
- read_log(): web log files
A.22 reprex
Package Profile: reprex
Convenience wrapper that uses the ‘rmarkdown’ package to render small snippets of code to target formats that include both code and output. The goal is to encourage the sharing of small, reproducible, and runnable examples on code-oriented websites, such as https://stackoverflow.com and https://github.com, or in email. The user’s clipboard is the default source of input code and the default target for rendered output. ‘reprex’ also extracts clean, runnable R code from various common formats, such as copy/paste from an R session.
A.23 rhino
Package Profile: rhino
A framework that supports creating and extending enterprise Shiny applications using best practices. Apply best software engineering practices, modularize your code, test it well, make UI beautiful, and think about user adoption from the very beginning. Rhino is an opinionated framework with a focus on software engineering practices and development tools.
A.24 rlang
Package Profile: rlang
The {rlang} package is a toolkit for working with core R and {tidyverse} features like tidy evaluation and is providing various interfaces for working with R and R objects. The package offers tools for handling the R session, environments, evaluation, calls and symbols, and functions. Additionally, it provides error handling tools, such as rlang::abort() for creating errors with bullet lists, structured metadata, and error chaining support.
A.25 shiny
Package Profile: shiny
Makes it incredibly easy to build interactive web applications with R. Automatic “reactive” binding between inputs and outputs and extensive prebuilt widgets make it possible to build beautiful, responsive, and powerful applications with minimal effort.
A.26 shinycssloaders
Package Profile: shinycssloaders
When a ‘Shiny’ output (such as a plot, table, map, etc.) is recalculating, it remains visible but gets greyed out. Using {shinycssloaders}, you can add a loading animation (“spinner”) to outputs instead. By wrapping a {shiny} output in withSpinner(), a spinner will automatically appear while the output is recalculating. You can also manually show and hide the spinner, or add a full-page spinner to cover the entire page. See the demo online at https://daattali.com/shiny/shinycssloaders-demo/. (The 8 built-in animations are taken from https://projects.lukehaas.me/css-loaders/.)
A.27 shinydashboard
Package Profile: shinydashboard
This package provides a theme on top of ‘Shiny’, making it easy to create attractive dashboards. The package allows users to build dashboards with a three-panel layout, including a header, sidebar, and body. It includes functions for creating various components such as headers, sidebars, and body elements, which help in structuring the dashboard. Additionally, {shinydashboard} supports the integration of various data visualization libraries like {ggplot2}, {plotly}, and {leaflet} to enhance interactivity and data representation.
A.28 shinyFeedback
Package Profile: shinyFeedback
Easily display user feedback in Shiny apps. {shinyFeedback} currently works with the following {shiny} inputs: dateInput(); dateRangeInput(); fileInput(); numericInput(); passwordInput(); selectInput(); sliderInput(); textAreaInput(); textInput():
Additionally it support also the {shinyWidgets} package with shinyWidgets::airDatepickerInput() and shinyWidgets::pickerInput().
A.29 shinylive
Package Profile: shinylive
Exporting ‘shiny’ applications with ‘shinylive’ allows you to run them entirely in a web browser, without the need for a separate R server. The traditional way of deploying ‘shiny’ applications involves in a separate server and client: the server runs R and ‘shiny’, and clients connect via the web browser.
When an application is deployed with ‘shinylive’, R and ‘shiny’ run in the web browser (via webR): the browser is effectively both the client and server for the application. This allows for your ‘shiny’ application exported by ‘shinylive’ to be hosted by a static web server or to run inside Quarto documents as I have extensively used in this book.
A.30 shinymaterial
Package Profile: shinymaterial
An R package that allows developers to implement Google’s Material Design https://m2.material.io/design in Shiny applications. It provides a set of UI elements and functions that enable the creation of visually appealing and modern web applications using R code. The package includes various components such as buttons, cards, dropdowns, and tabs, which are styled according to Material Design principles.
A.31 shinymeta
Package Profile: shinymeta
Provides tools for capturing logic in a Shiny app and exposing it as code that can be run outside of Shiny (e.g., from an R console). It also provides tools for bundling both the code and results to the end user.
Learn more about the {shinymeta} package in Joe Cheng’s useR! 2019 keynote, “Shiny’s holy grail1: Interactivity with reproducibility”. The code for the example Shiny app is available at GitHub. The sample code is useful in its own. It features package download data from r glossary("CRAN").
Keep in mind that there were breaking changes in the meantime by replacing bang-bang (!!) with the dot-dot operator (..()).
A.32 shinyMobile
Package Profile: shinyMobile
Develop outstanding ‘shiny’ apps for ‘iOS’ and ‘Android’ as well as beautiful ‘shiny’ gadgets. ‘shinyMobile’ is built on top of the latest ‘Framework7’ template https://framework7.io. Discover 14 new input widgets (sliders, vertical sliders, stepper, grouped action buttons, toggles, picker, smart select, …), 2 themes (light and dark), 12 new widgets (expandable cards, badges, chips, timelines, gauges, progress bars, …) combined with the power of server-side notifications such as alerts, modals, toasts, action sheets, sheets (and more) as well as 3 layouts (single, tabs and split).
A.33 shinysnippets
Package Profile: shinysnippets
A series of shiny related RStudio Snippets. The goal of shinysnippets is to save development time while taking advantage of Rstudio snippets for Shiny applications.
A.34 shinyvalidate
Package Profile: shinyvalidate
Improves the user experience of Shiny apps by helping to provide feedback when required inputs are missing, or input values are not valid. It allows developers to add validation rules to their Shiny applications to ensure that user inputs meet certain criteria before processing. It aims to provide minimalist feedback that supports a larger set of components and is extensible for custom inputs.
A.35 shiny.semantic
Package Profile: shiny.semantic
Creating a great user interface for your Shiny apps can be a hassle, especially if you want to work purely in R and don’t want to use, for instance HTML templates. This package adds support for a powerful UI library Fomantic UI - https://fomantic-ui.com/ (before Semantic). It also supports universal UI input binding that works with various DOM elements.
A.36 showtext
Package Profile: showtext
Making it easy to use various types of fonts (‘TrueType’, ‘OpenType’, Type 1, web fonts, etc.) in R graphs, and supporting most output formats of R graphics including PNG, PDF and SVG. Text glyphs will be converted into polygons or raster images, hence after the plot has been created, it no longer relies on the font files. No external software such as ‘Ghostscript’ is needed to use this package.
A.37 stringi
Package Profile: stringi
A collection of character string/text/natural language processing tools for pattern searching (e.g., with ‘Java’-like regular expressions or the ‘Unicode’ collation algorithm), random string generation, case mapping, string transliteration, concatenation, sorting, padding, wrapping, Unicode normalization, date-time formatting and parsing, and many more.
The {stringi} tools are fast, consistent, convenient, and - thanks to r glossary("ICU") (International Components for Unicode) - portable across all locales and platforms. Documentation about {stringi} is provided via its website at https://stringi.gagolewski.com/ and the paper by Gagolewski (2022b).
A.38 stringr
Package Profile: stringr
A consistent, simple and easy to use set of wrappers around the fantastic ‘stringi’ package. All function and argument names (and positions) are consistent, all functions deal with “NA”’s and zero length vectors in the same way, and the output from one function is easy to feed into the input of another.
Strings are not glamorous, high-profile components of R, but they do play a big role in many data cleaning and preparation tasks. The {stringr} package provides a cohesive set of functions designed to make working with strings as easy as possible. If you’re not familiar with strings, the best place to start is the chapter on strings in R for Data Science.
A.39 styler
Package Profile: styler
The R package styler is a tool for non-invasive pretty printing of R code, allowing users to format their code according to a style guide without altering the original formatting intent. It helps maintain consistent coding styles across projects and facilitates collaboration. The package defaults to the tidyverse style guide but also allows for custom style guides.
A.40 testthat
Package Profile: testthat
Software testing is important, but, in part because it is frustrating and boring, many of us avoid it. ‘testthat’ is a testing framework for R that is easy to learn and use, and integrates with your existing ‘workflow’.
A.41 thematic
Package Profile: thematic
Theme ‘ggplot2’, ‘lattice’, and ‘base’ graphics based on a few choices, including foreground color, background color, accent color, and font family. Fonts that aren’t available on the system, but are available via download on ‘Google Fonts’, can be automatically downloaded, cached, and registered for use with the {showtext} and {ragg} packages.
A.42 tibble
Package Profile: tibble
A tibble, or tbl_df, is a modern reimagining of the data.frame, keeping what time has proven to be effective, and throwing out what is not.
Tibbles are data.frames that are lazy and surly: they do less (i.e. they don’t change variable names or types, and don’t do partial matching) and complain more (e.g. when a variable does not exist). This forces you to confront problems earlier, typically leading to cleaner, more expressive code. Tibbles also have an enhanced print() method which makes them easier to use with large datasets containing complex objects.
A.43 tidyr
Package Profile: tidyr
The goal of {tidyr} is to help you create tidy data. Tidy data describes a standard way of storing data that is used wherever possible throughout the {tidyverse}. If you ensure that your data is tidy, you’ll spend less time fighting with the tools and more time working on your analysis.
Tidy data is data where: - Every column is a variable. - Every row is an observation. - Every cell is a single value.
A.44 tidyverse
Package Profile: tidyverse
The {tidyverse} is an opinionated collection of R packages designed for data science. It includes a set of packages that work in harmony because they share common data representations and API design. The core tidyverse packages include {dplyr}, {ggplot2}, {tidyr}, {readr}, {purrr}, {tibble}, {stringr}, and {forcats}. These packages provide functionality to model, transform, and visualize data.
In this book I am not going to load {tidyverse} with all its packages. Instead I am using the <package>::<function> format to access the commands. Explicitly mentioned the used packages with every function call helps me to learn which package is responsible for which function.
A.45 vroom
Package Profile: vroom
The goal of ‘vroom’ is to read and write data (like ‘csv’, ‘tsv’ and ‘fwf’) quickly. When reading it uses a quick initial indexing step, then reads the values lazily , so only the data you actually use needs to be read. The writer formats the data in parallel and writes to disk asynchronously from formatting.
A.46 waiter
Package Profile: waiter
Provides functionality for adding loading screens and progress bars to Shiny applications. It allows developers to show partial or full-page loading screens with spinners or loading bars to inform users that the application is processing data or performing computations.
A.47 withr
Package Profile: withr
A set of functions to run code ‘with’ safely and temporarily modified global state. Many of these functions were originally a part of the {devtools} package, this provides a simple package with limited dependencies to provide access to these functions.
References
Attention: The video starts at minute 11:20.↩︎