Glossary
This appendix collects, in one alphabetical list, the concepts defined in each chapter’s ‘vocabulary of this chapter’ section together with the commands, functions, tools, and services the book relies on. The per-chapter vocabulary sections remain in place; this is a second view of them and not a replacement.
Each entry names the chapter that introduces or develops it, and a term developed in more than one chapter names each. Entries are alphabetized by the term itself, so a function is filed under its own name rather than under the package that supplies it: look for tar_make() under T and renv::restore() under R.
A
apptainer build. Converts an OCI image into a single SIF file that runs without root, which is what makes it acceptable on a shared cluster and depositable as an archival artifact. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
Apptainer (formerly Singularity). A container runtime built for shared high-performance computing, where users are not administrators. Its SIF format is a single checksummable file. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
Archetype. The kind of research object a compendium is (data analysis, manuscript, package, simulation study, or blog), which varies the layout and the gates but not the underlying machinery. (5 The Research Compendium)
B
Backend. The mechanism that supplies the environment. Docker is the container backend; Nix is a container-free backend that declares the environment directly. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
Base image. The starting image a recipe builds on, named on the FROM line. Here, a Rocker image providing a fixed R version on a fixed operating system. (7 Pinning the Environment with Docker)
Binder. A service that builds an environment from a public repository and serves it in a browser, so a reviewer can run an analysis with nothing installed locally. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
Branch. A movable name for a line of development. The default branch is conventionally called main. (4 Version Control with Git and GitHub)
C
Capture. Fixing an input so that it cannot drift: writing a lockfile, building a container image. Capture sets the reproducibility level. (3 Levels of Reproducibility)
Checksum. A short fingerprint, computed from a file’s or an object’s bytes by a hash function such as SHA-256, with the property that any change to the input, however small, changes the fingerprint. A stored checksum lets a later run detect that an input has been altered. (12 Continuous Integration and Verification)
Code chunk. A block of executable code embedded in a literate document, delimited from the prose, whose output is inserted into the rendered document at the chunk’s position. (9 Literate Programming and the Rendered Report)
CODECHECK. A scheme in which an independent person re-runs a submitted analysis and certifies the result, catching the class of failure where the author’s own checks encode the author’s own assumptions. (12 Continuous Integration and Verification)
Codespaces and devcontainers. A specification, and a hosted implementation of it, for describing the development environment an editor should open a project inside. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
Commit. A recorded snapshot of the tracked files at one moment, carrying an author, a timestamp, a message, and an immutable identifier (a hash). The atomic unit of history. (4 Version Control with Git and GitHub)
Computational reproducibility. Obtaining the same numerical results from the same data and the same code, on another machine or at a later time. (2 The Reproducibility Crisis)
conda and pixi. Cross-language environment managers that pin R and Python packages without a container. pixi is the option that reproduces natively on Windows. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
Container. A running instance of an image. One image can start many containers; each begins from the same frozen filesystem. (7 Pinning the Environment with Docker)
Container image. A packaged environment, built from a recipe, that carries the operating system, the system libraries, and the language runtime, and runs identically wherever a container runtime runs. (3 Levels of Reproducibility)
Content hash. A short fingerprint computed from a package’s contents, so that two installations claiming the same version can be confirmed byte-identical. (6 Pinning Packages with renv)
Continuous integration (CI). A hosted service that, on every committed change to a repository, checks out the code onto a fresh virtual machine, rebuilds the project, and runs a defined set of checks, reporting success or failure automatically. (12 Continuous Integration and Verification)
D
Daemon. A background system service that runs continuously with elevated privilege. Docker relies on one; Podman and Apptainer do not, which is why they run without administrative rights. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
Data-validation test. A check on the data itself rather than the code: that a value lies in a plausible range, that no impossible ages appear, that the expected columns are present. (11 Testing and Code Quality)
Dated snapshot. A view of a repository frozen as it stood on a particular calendar day, so that an install run today and one run next year fetch the same versions. (6 Pinning Packages with renv, 7 Pinning the Environment with Docker)
Dependency graph. The graph whose nodes are the steps and whose edges record that one step consumes what another produces. A valid pipeline’s graph is a directed acyclic graph (DAG): directed because inputs flow to outputs, and acyclic because a step cannot, directly or transitively, depend on its own output. (10 Automating the Analysis: Make and targets)
Dependency-manifest gate. A CI check that enforces the dependency invariant of 6 Pinning Packages with renv. In its strict, R-package form it requires every package the code uses to be declared in DESCRIPTION and pinned in renv.lock. For a research compendium, whose DESCRIPTION declares only the API exported from R/ while analysis scripts legitimately draw on packages present in renv.lock but not in DESCRIPTION, it enforces the weaker inclusion that every package the code uses is pinned in renv.lock. (12 Continuous Integration and Verification)
DESCRIPTION. The human-authored file that declares a project’s direct dependencies by role (Imports, Suggests, Depends), with optional version floors. (6 Pinning Packages with renv)
Determinant stack. The layered set of things a computational result depends upon, from the hardware at the base through the environment and the packages to the analysis code and the data at the top. A layer is ‘pinned’ when it has been fixed to a recorded value. (2 The Reproducibility Crisis, 3 Levels of Reproducibility)
Determinism (of a render). The property that rendering the same source under the same environment produces a byte-for-byte identical output file. A rendered PDF is usually not deterministic in this strict sense, for reasons developed below. (9 Literate Programming and the Rendered Report)
digest(). Computes a content hash of an R object. Used to verify that a regenerated computational output matches a recorded one, on objects rather than on rendered documents. (12 Continuous Integration and Verification)
Docker. The most widely used container platform, and one instrument for reaching a pinned environment rather than a synonym for reproducibility. (7 Pinning the Environment with Docker)
docker build and docker run. Build an image from a recipe and start a container from an image. The image is durable; the container is ephemeral. (7 Pinning the Environment with Docker)
Docker Hub and GHCR. Container registries. A pushed image is a cache and not the record: the committed recipe is the record, because a registry can delete, rate-limit, or repoint what it holds. (13 Collaboration, Archiving, and Stewardship)
docker pull and docker inspect. Fetch an image and read its metadata, including the content digest that a reproducible recipe pins instead of a tag. (7 Pinning the Environment with Docker)
E
Expectation. A single assertion, such as expect_equal(actual, expected), that passes or fails. (11 Testing and Code Quality)
expect_equal() and the other expectations. The assertions of tinytest. A file of bare, top-level expectation calls is a complete test file, and expect_inherits(), expect_true(), and expect_error() cover most of the rest. (11 Testing and Code Quality)
F
FAIR. A set of principles holding that a research object should be Findable, Accessible, Interoperable, and Reusable, formulated for data and later adapted for research software. (13 Collaboration, Archiving, and Stewardship)
Forge. A platform that hosts a version-controlled repository and runs its continuous integration. GitHub and GitLab are the two principal forges; GitLab is frequently self-hosted by universities. (12 Continuous Integration and Verification, 13 Collaboration, Archiving, and Stewardship)
G
git add. Stages changes for the next commit. Staging is what lets a commit be one idea rather than a snapshot of whatever is on disk. (4 Version Control with Git and GitHub)
git clone, push, pull, fetch. Move history between a local repository and a remote. A remote serves backup, distribution, and collaboration, which are three purposes worth keeping separate. (4 Version Control with Git and GitHub)
git commit. Records the staged changes with a message and an immutable identifier. The atomic unit of the history. (4 Version Control with Git and GitHub)
git diff. Shows what changed, between the working tree and the index, or between any two commits. (4 Version Control with Git and GitHub)
git filter-repo. Rewrites history to remove content, producing new hashes for every commit from the offending one forward. The tool of last resort after protected data has been committed, and no substitute for notifying whoever is responsible for the data. (4 Version Control with Git and GitHub)
git init. Creates a repository in a directory. The .gitignore should be written before the first commit, not after. (4 Version Control with Git and GitHub)
git log and git show. Read the history: log lists commits, show prints one commit’s message and its diff together. (4 Version Control with Git and GitHub)
git switch and git merge. Move between branches and rejoin them. A merge commit is the only commit with two parents, which is what records that two lines of work came back together. (4 Version Control with Git and GitHub)
git tag. Marks a particular commit permanently, such as the state of an analysis at submission. Cheap to place and expensive to omit. (4 Version Control with Git and GitHub)
GitHub Actions. GitHub’s continuous-integration service, configured by YAML workflow files under .github/workflows/. (12 Continuous Integration and Verification)
GitHub and GitLab. The two principal forges. GitLab is frequently self-hosted by institutions that forbid pushing to a public forge, and a compendium’s reproducibility machinery should be portable between them. (13 Collaboration, Archiving, and Stewardship)
.gitignore. A file listing path patterns that git should not track, used to keep derived outputs, large data, and, critically, sensitive files out of the history. (4 Version Control with Git and GitHub)
groundhog.library(). Loads a package as it stood on a given date, a lighter alternative to a lockfile that reconstructs by date rather than by record. (6 Pinning Packages with renv)
I
Image. A frozen, read-only filesystem together with metadata, bundling an operating system, R, a set of packages, and configuration. It is analogous to a snapshot of a fully installed computer, packaged so it can be shipped. (7 Pinning the Environment with Docker)
Input-addressed. Identified by a hash of the build inputs rather than by a mutable name, so that a reference cannot silently point at different content later. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
install.packages(). Base R’s installer. Pointed at a live repository it resolves ‘the current version’ to whatever is current on the day it runs, which is why a reproducible recipe points it at a dated snapshot or replaces it with a lockfile restore. (6 Pinning Packages with renv)
Integration test. A check that several components behave correctly when composed into a pipeline, from raw input to final result. (11 Testing and Code Quality)
Invalidation. The act of marking a target out of date because something it depends on, a file, an upstream target, a function, or a package, has changed. (10 Automating the Analysis: Make and targets)
K
knitr and Sweave. The engines that execute code inside a literate document. Sweave came first; knitr superseded it and underlies both R Markdown and Quarto’s R support. (9 Literate Programming and the Rendered Report)
L
Landmine. A pattern in a document that makes the render succeed for its author and fail for a later reader, by reaching outside the captured and committed material. (9 Literate Programming and the Rendered Report)
LaTeX and TinyTeX. The typesetting system a PDF render requires, and a small R-managed distribution of it. Belongs in the image rather than assumed on the host. (9 Literate Programming and the Rendered Report)
Layer. Each instruction in an image’s recipe produces one filesystem layer. An image is the stack of its layers, and identical layers are shared and cached across images. (7 Pinning the Environment with Docker)
library() and require(). The two calls that attach a package to the current session. Both are scanned when a dependency check derives what the code uses, so a package loaded this way must be declared and pinned. (6 Pinning Packages with renv)
Linting. Static analysis of source code for stylistic and likely-error patterns, performed by lintr, without running the code. (11 Testing and Code Quality)
lintr and styler. Static analysis and automatic reformatting for R source. Legibility is a validation feature: code nobody can read is code nobody can check. (11 Testing and Code Quality)
Literate programming. Writing narrative prose and executable code together in one source document, so the document is at once the program and its explanation. The term is Knuth’s. (9 Literate Programming and the Rendered Report)
Lockfile. A machine-generated file, renv.lock, recording the exact version, source repository, and content hash of every package in a project’s library. (3 Levels of Reproducibility, 6 Pinning Packages with renv)
M
make. Rebuilds targets whose modification time is older than a prerequisite’s. Conservative in one direction and unreliable in the other: it will rebuild what did not need it, and miss a change that leaves timestamps untouched. (10 Automating the Analysis: Make and targets)
N
Nix and Guix. Declarative package managers that pin an entire dependency graph, from the system libraries upward, to a single revision. They reach a pinned environment from a recipe rather than from a built artifact. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
O
OCI image. An image built to the Open Container Initiative specification, the common format that Docker, Podman, and Apptainer can all consume. A Docker image is an OCI image. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
OCI tarball or SIF file. A container image exported as a single file, checksummable and depositable as an archival artifact. An OCI image is exported as a tar archive, whereas SIF is the self-contained single-file format used by the Apptainer runtime. (13 Collaboration, Archiving, and Stewardship)
Oracle. The source of independent truth a test compares against; the known correct answer. (11 Testing and Code Quality)
P
Package churn (code rot). The gradual breakage of once-working code as the packages beneath it are updated over time. (2 The Reproducibility Crisis)
Package library. The directory into which R installs packages. A project-local library belongs to one project rather than being shared across all of a user’s work. (6 Pinning Packages with renv)
Package repository. A server, such as CRAN or the Posit Package Manager, from which packages are installed. (6 Pinning Packages with renv)
pacman::p_load(). Loads packages and installs any that are missing. Convenient and a landmine in a sealed document: it reaches the network at render time and pins nothing. (9 Literate Programming and the Rendered Report)
pandoc. The document converter a render invokes after the code has run, turning the executed markdown into the requested output format. (9 Literate Programming and the Rendered Report)
Persistent identifier (DOI). A durable, resolvable name for a deposited artifact, such as a Digital Object Identifier, that continues to resolve even if the artifact moves. (13 Collaboration, Archiving, and Stewardship)
Pipeline. An analysis expressed as a set of steps, each declaring its inputs and outputs, so that the whole can be re-executed by a single command that runs the steps in dependency order. (10 Automating the Analysis: Make and targets)
pkg::fun(). A namespaced call, which uses a function without attaching its package. It still creates a dependency, and a scanner that looked only for library() would miss it. (6 Pinning Packages with renv)
Podman. A daemonless, rootless container runtime that runs the same images as Docker. The usual answer where Docker Desktop licensing is a constraint. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
podman run. Starts a container without a root daemon, consuming the same image format Docker produces. Swapping the runtime changes the launcher and not the reproducibility level. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
Posit Package Manager. A package repository that serves dated snapshots and prebuilt binaries, so that an install run today and one run next year fetch the same versions. (6 Pinning Packages with renv)
precommit. Runs checks before a commit is recorded, keeping trivia out of the history. It can be skipped, which is why it complements rather than replaces continuous integration. (11 Testing and Code Quality)
Pre-commit hook. A script that git runs automatically before a commit is recorded, used here to run the linter and the styler as a gate. (11 Testing and Code Quality)
Prerequisite. In Make, an input a target depends on. If any prerequisite is newer than the target, the target is out of date. (10 Automating the Analysis: Make and targets)
Profile. The base-image bundle a project is built from, such as minimal, tidyverse, rstudio, or publishing. It selects the FROM image. (7 Pinning the Environment with Docker)
Progressive disclosure. The property that one layout supports a project’s evolution from one archetype to another with no reorganization. (5 The Research Compendium)
Pull request (merge request). A proposal, made on the remote, to merge one branch or fork into another, reviewed before it is accepted. (4 Version Control with Git and GitHub)
Purely functional package manager. A package manager, such as Nix, in which the installed result is a deterministic function of the declared inputs, so that the same declaration yields a deterministic, reproducible environment. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
Q
Quarto and R Markdown. The literate-document systems this book uses: prose and executable code in one source, rendered to HTML, PDF, and other formats. (9 Literate Programming and the Rendered Report)
quarto render. Executes a document’s code and produces its output formats. With freeze configured it may replay a cache instead of executing, which is why a gate that must exercise the code has to clear the cache first. (9 Literate Programming and the Rendered Report)
R
R CMD check. The standard R command that builds a package, runs its tests, and applies dozens of standardized checks; here it serves as a universal integrity gate on the whole compendium. (5 The Research Compendium, 12 Continuous Integration and Verification)
rang, groundhog, and capsule. Lighter alternatives to a lockfile that reconstruct a package set from a date. Useful when no lockfile survives, and an approximation rather than a record. (6 Pinning Packages with renv)
Raw versus derived data. Immutable original inputs versus the processed datasets regenerated from them by code. (5 The Research Compendium)
Recipe (or command). The shell command Make runs to bring a target up to date from its prerequisites. (10 Automating the Analysis: Make and targets)
Registry. A server that stores and distributes container images, from which collaborators pull a pre-built environment. GitHub Container Registry (GHCR) and Docker Hub are the two in common use. (13 Collaboration, Archiving, and Stewardship)
Remote. A copy of the repository hosted elsewhere, typically on GitHub or GitLab, used for backup, distribution, and collaboration. origin is the conventional name of the primary remote. (4 Version Control with Git and GitHub)
remotes::install_github(). Installs a package from a git repository rather than a package repository. Reproducible only if pinned to a commit or a tag. (13 Collaboration, Archiving, and Stewardship)
Render gate. A CI check that re-renders the compendium’s report (an R Markdown or Quarto document) from source and fails the build if the render errors. (5 The Research Compendium, 12 Continuous Integration and Verification)
Render (verb and noun). To execute a literate source document and produce a finished output file (HTML, PDF, Word); and the resulting file itself. (9 Literate Programming and the Rendered Report)
Rendering toolchain. The programs a render invokes behind the scenes: knitr or the Quarto engine to run the code, pandoc to convert the result, and, for PDF, a LaTeX distribution to typeset it. (9 Literate Programming and the Rendered Report)
renv and packrat. The current and superseded R dependency managers. Both pair a project-local library with a lockfile; renv rebuilt the interface around a small set of verbs and a shared cache. (6 Pinning Packages with renv)
renv::init(). Creates a project-local library and lockfile, taking a project from unpinned to pinned packages. (6 Pinning Packages with renv)
renv::restore(). Reads the lockfile and installs the recorded versions into the library. The command a collaborator runs on a fresh clone. (6 Pinning Packages with renv)
renv::snapshot(). Reads the library and writes what it finds into the lockfile. Snapshot writes; restore reads. (6 Pinning Packages with renv)
renv::status(). Reports disagreement between the library and the lockfile, and is the first diagnostic when a restore appears not to have worked. (6 Pinning Packages with renv)
Replicability. Obtaining consistent findings from a new study, with new data, aimed at the same question. (2 The Reproducibility Crisis)
Repository (repo). A directory whose contents and full history git tracks, held in a hidden .git subdirectory. A clone is a complete copy of a repository, history and all. (4 Version Control with Git and GitHub)
Reproduced. Obtaining the same computational result by re-executing the same code on the same data. Contrast replicated, obtaining a consistent finding from a new study with new data. (3 Levels of Reproducibility)
Reproducibility test. A check that a recorded computational result regenerates, either across repeated runs with a fixed seed or against a stored baseline. (11 Testing and Code Quality)
Research compendium. A single self-describing directory bundling the code, data, prose, and environment record of an analysis, organized by convention so that it can be located and re-run. (2 The Reproducibility Crisis, 5 The Research Compendium)
Restore. The reverse act of reading the lockfile and reinstalling exactly the packages it records. (6 Pinning Packages with renv)
rix::rix(). Generates a default.nix pinning an R version, a package set, and the nixpkgs revision that determines everything beneath them. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
RNG kind. The random-number algorithm in force, set by RNGkind(). Two runs with the same seed but a different kind draw different numbers. (3 Levels of Reproducibility)
RNGkind(). Selects the random-number generator algorithm. Its sample.kind default changed in R 3.6.0, so the same seed draws different numbers under different R versions unless the kind is recorded. (2 The Reproducibility Crisis)
Robustness. Reaching the same qualitative conclusion from the same data under different but defensible analytical choices. (2 The Reproducibility Crisis)
Rocker. The community project that publishes the standard R Docker images. (7 Pinning the Environment with Docker)
Rootless. Able to run under an ordinary user account, without the root superuser privilege. A requirement on shared clusters, where users are not administrators. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
R-package skin. The minimal set of files (DESCRIPTION, NAMESPACE, an R/ directory) that makes a directory a valid R package, and therefore checkable by the R build tools. (5 The Research Compendium)
Runner. The fresh, ephemeral machine (usually a virtual machine or a container) on which the CI service executes the workflow. It is discarded after the run, so nothing persists between runs except what the workflow explicitly restores. (12 Continuous Integration and Verification)
Runtime. The program that runs a container image: Docker, Podman, or Apptainer. The runtime is interchangeable when the image is a standard OCI image. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
S
saveRDS() and readRDS(). Write and read a single R object to a file. The ordinary way to record the baseline that a reproducibility test compares against. (11 Testing and Code Quality)
Sealed render. A document in which every reported number and figure is regenerated from the code that produces it on each build, so the prose cannot drift from the analysis. (9 Literate Programming and the Rendered Report)
Seed and RNG kind. The seed (set.seed) is the fixed starting point that makes a random draw repeatable; the RNG kind is the generator algorithm that turns that seed into numbers, and its default has changed across R versions. (2 The Reproducibility Crisis)
sessionInfo(). Reports the R version, platform, and attached packages of the current session. A record of what ran, not a mechanism for making it run again. (3 Levels of Reproducibility)
set.seed(). Fixes the starting point of the random-number stream so that a stochastic result repeats. Necessary but not sufficient: the generator algorithm must be fixed as well. (2 The Reproducibility Crisis)
SIF. The Singularity Image Format, a single-file archive that Apptainer produces from an image, suitable for depositing alongside a compendium. (8 Backends and Runtimes: Nix, Podman, and Apptainer)
Silent default. A behavior that software applies unless told otherwise, and that can change between software versions without any error or warning to the analyst. (2 The Reproducibility Crisis)
Snakemake and Nextflow. Pipeline tools from the bioinformatics community, language-agnostic and built for cluster execution. (10 Automating the Analysis: Make and targets)
Snapshot. The act of scanning a project, resolving the versions currently installed, and writing them into the lockfile. (6 Pinning Packages with renv)
SOURCE_DATE_EPOCH. A conventional environment variable, honored by many document tools, that fixes the timestamp a build embeds, so that two builds do not differ merely because they ran at different moments. (9 Literate Programming and the Rendered Report)
Staging area (index). The set of changes marked, with git add, to go into the next commit. Staging lets a commit hold a chosen subset of the current changes. (4 Version Control with Git and GitHub)
Staleness (out-of-date). The condition of a target whose inputs have changed since it was last built, so that its stored output no longer reflects its inputs. (10 Automating the Analysis: Make and targets)
Styling. Automatic reformatting of source code to a consistent layout, performed by styler. (11 Testing and Code Quality)
T
Tag. A permanent, human-readable name for one specific commit, used to mark a milestone such as a manuscript submission. (4 Version Control with Git and GitHub)
Tag and digest. A tag, such as rocker/tidyverse:4.4.0, is a human-readable pointer that may later be repointed. A digest, @sha256:..., is an immutable hash of the image’s exact content. The same digest always denotes byte-identical bytes. (7 Pinning the Environment with Docker)
Target. A single step in the pipeline, together with the output it produces. The word is shared by Make and targets, with a shift of emphasis: for Make a target is a file, for targets it is more often an R object. (10 Automating the Analysis: Make and targets)
targets. A function-oriented pipeline tool for R that hashes function bodies and R objects rather than file timestamps, so it detects changes a Makefile can miss. (10 Automating the Analysis: Make and targets)
tar_make(). Runs a targets pipeline, rebuilding only the targets that are out of date and everything downstream of them. (10 Automating the Analysis: Make and targets)
tar_outdated(). Reports which targets tar_make() would rebuild, without rebuilding them. The way to check a prediction about the dependency graph before paying for it. (10 Automating the Analysis: Make and targets)
tar_target(). Declares one node of a targets pipeline: a name, the expression that computes it, and optionally a format such as file. (10 Automating the Analysis: Make and targets)
tar_visnetwork(). Draws the pipeline’s dependency graph, derived from the code rather than from a hand-maintained declaration. (10 Automating the Analysis: Make and targets)
The Five Pillars. The five artifacts a compendium manages, one per capture point: the Dockerfile, renv.lock, .Rprofile, the source code, and the data. (5 The Research Compendium)
The level ladder (L0 to L3). The four-rung scale, L0 locatable, L1 pinned packages, L2 pinned environment, L3 verified, used throughout this book to grade how far down the stack an analysis has been secured. (3 Levels of Reproducibility)
tinytest. A lightweight, zero-dependency R testing framework in which a test file is a plain script of bare, top-level expectation calls (Loo, 2020). (11 Testing and Code Quality)
tinytest and testthat. R testing frameworks. tinytest has no dependencies and its test files are plain scripts of bare expectations, which is why this book uses it. (11 Testing and Code Quality)
Two-layer team model. A division of a project into a slow-moving environment layer, fixed once by a team lead, and a fast-moving package layer, extended by every contributor. (13 Collaboration, Archiving, and Stewardship)
U
Union model. The rule that the project lockfile records the union of every package any contributor has installed, so that a rebuilt image carries what the whole team needs, not only what one member used. (13 Collaboration, Archiving, and Stewardship)
Unit test. A focused check that one small piece of code, typically a single function, behaves as intended on known inputs. (11 Testing and Code Quality)
Up-to-date (skippable). The condition of a target whose inputs have not changed since it was last built, so that rebuilding it would reproduce the stored output and can be skipped. (10 Automating the Analysis: Make and targets)
V
Validation. Confirming that the captured inputs actually suffice, by rebuilding and re-running. Validation does not pin anything new; it checks. (3 Levels of Reproducibility)
Verification. The act of rebuilding the compendium, re-running the analysis, and comparing the regenerated computational outputs against a recorded baseline; passing it is what the ladder calls level L3. (12 Continuous Integration and Verification)
W
Workflow. The file, written in YAML, that tells the CI service what to do: which events trigger it, what environment to run in, and what commands to execute. On GitHub these files live under .github/workflows/; on GitLab the single file is .gitlab-ci.yml. (12 Continuous Integration and Verification)
Working tree. The ordinary files in the repository directory as they currently exist on disk, as opposed to the versions recorded in the history. (4 Version Control with Git and GitHub)
Z
Zenodo. A general-purpose research repository, operated at CERN, that mints a DOI for any deposited file set. (13 Collaboration, Archiving, and Stewardship)
zzcollab. The framework this book uses to compose the reproducibility tools into one system, organized around the levels ladder. (5 The Research Compendium)
zzrenvcheck::check_packages(). Checks the dependency triad and can repair it, writing a missing package into DESCRIPTION and injecting a resolved entry into the lockfile. (6 Pinning Packages with renv)