Appendix J — Glossary

A working glossary of the computing terms used throughout Computational Tools for Bioengineers (BIOE 610): computer hardware and operating systems, the Unix command line, shell scripting and regular expressions, R and Python, Quarto and Markdown, Git and GitHub, common data formats, and high-performance computing on the University of Oregon’s Talapas cluster. Terms in italics inside a definition have their own entry. For longer explanations, see the chapters of this book, for example the Unix Fundamentals chapter and Appendix: Common Data Formats & Public Repositories.

J.1 A

Absolute path
The full address of a file or directory from the filesystem root (/ on Unix/macOS, C:\ on Windows), unambiguous regardless of where you are when you type it, e.g., /home/you/projects/tissue_scaffold/data/measurements.csv. Contrast with relative path. Learn more →
Agentic coding tool
An AI assistant that does not just propose code but acts: it edits files, runs commands, and reads the output. Examples include Claude Code and GitHub Copilot’s agent mode. Use only inside a committed Git repository. See Chapter 18.
Algorithm
A pre-defined set of instructions to solve a problem. Learn more →
Apptainer
The HPC-safe successor to Singularity that runs OCI/Docker container images on shared clusters without requiring root access. On Talapas it is loaded with module load apptainer, used to apptainer pull an image from Docker Hub, and then apptainer exec <image.sif> <command> inside a batch job, giving stronger environment isolation than renv or conda alone. Learn more →
Argument
A value passed to a function or a shell command that tells it what to act on or how to behave. In R, arguments can be positional (order matters) or named (e.g., log(x, base = 10)); named arguments make long function calls easier to read. In the shell, arguments follow the command name after any flags, e.g., grep "ACGT" sequences.txt. Learn more →

J.2 B

3-2-1 backup rule
A rule of thumb for protecting important files: keep three copies, on two different kinds of storage, with one copy off-site. For example, the working copy on your laptop, a versioned backup on an external drive (Time Machine or File History), and a copy in OneDrive or a lab server, with code also on GitHub. A synced cloud folder alone is not a backup, because deletions and overwrites sync too. See Chapter 3. Learn more →
Backfill
A SLURM scheduling technique in which the scheduler fills gaps between higher-priority jobs with smaller, shorter requests that fit within the available window. Because of backfill, requesting only the resources a job genuinely needs is not only polite cluster etiquette but also gets your job started sooner. Learn more →
BAM
The binary, compressed version of a SAM file, storing sequencing read alignments to a reference genome. BAM files contain the same information as SAM files (read sequences, quality scores, alignment positions) in a space-efficient format that is faster to process. Inspect them with samtools view. Learn more →
Bash
The Bourne-Again SHell, the default shell on most Linux systems and common on macOS. Bash interprets the commands you type in a terminal, runs programs, expands wildcards, and executes shell scripts. The same Bash commands work on your laptop, in WSL on Windows, and on an HPC cluster such as Talapas. Learn more →
Batch job
A unit of work submitted to a scheduler via sbatch that runs unattended on a compute node. The job waits in the queue, runs when resources are granted, and writes its output to log files, so it keeps running after you log out or close your laptop. Contrast with an interactive session. Learn more →
BED
A tab-delimited format for genomic intervals (chromosome, start, end, plus optional name/score/strand columns) used for peaks, target regions, and annotations. Unlike GFF3/GTF and VCF, BED uses 0-based, half-open coordinates (start inclusive, end exclusive). Learn more →
Benchmark
An (ideally independent) comparison of the performance of several tools or computers with respect to pre-defined metrics such as speed, memory use, or accuracy. Learn more →
BGZF
Block Gzip Format, a variant of gzip that compresses data in fixed-size blocks so that random-access seeks within the file are possible. It is the compression used by BAM files and by bgzipped VCF or BED files that are indexed with tabix. Learn more →
Bioconda
A channel for the conda/mamba package manager that provides pre-built bioinformatics tools (aligners, quality-control utilities, R and Python packages) in isolated, versioned environments; often combined with Snakemake or Nextflow and Apptainer to build fully reproducible HPC workflows. Learn more →
Bioconductor
An open-source repository and ecosystem of R packages for analyzing high-throughput biological data (sequencing, microarrays, flow cytometry, imaging). Packages are installed with BiocManager::install() rather than install.packages(). Learn more →
Brace expansion
A Bash feature that generates several strings from one pattern in braces: mkdir -p project/{data/{raw,processed},scripts,output} creates the whole directory tree in one command, and cp file.txt{,.bak} makes a backup copy. Unlike a wildcard, brace expansion does not look at existing files; it simply expands the text. Learn more →
Branch
In Git, an independent line of development diverging from a common commit history. Branches let collaborators add features or test ideas without affecting the main branch; they are later merged back when ready. Learn more →

J.3 C

Cache
A small, very fast memory layer built into the CPU that holds recently used data and instructions so the processor does not have to fetch them from slower RAM on every cycle. L1, L2, and L3 caches sit between the processor cores and main memory in the storage hierarchy. Learn more →
CBDS (Center for Biomedical Data Science)
A center at the University of Oregon’s Knight Campus that supports the computational and data-science side of biomedical research, including training such as this course. See Chapter 3 for UO computing support and where to get help.
Checkpoint (pipeline)
An intermediate output file (for example an .rds or .csv file) written to disk after each stage of a multi-step pipeline so that a later stage can be re-run from that point without repeating all preceding steps. Checkpoints are a natural hand-off between separate batch jobs. Learn more →
Clock speed
The rate at which a CPU executes its basic fetch-decode-execute cycle, measured in gigahertz (GHz). A higher clock speed means each individual operation completes faster, but for parallel scientific workloads the number of cores is often the more important spec. Learn more →
Clone
The Git operation (git clone <url>) that downloads a complete copy of a remote repository, including its full commit history, branches, and tags, to your local machine. Learn more →
Command line (CLI)
A text-based interface for interacting with a computer’s operating system by typing commands into a terminal; also called the command-line interface. The command line is scriptable, composable, and works the same on a laptop and on a remote HPC cluster, which makes it essential for data-intensive bioengineering work. Learn more →
Commit
A snapshot of a project’s files recorded by Git, identified by a unique hash and accompanied by an author, timestamp, and descriptive message; the fundamental unit of Git history. Created with git commit -m "message" after staging changes. Learn more →
Compiled language
A programming language (C, C++, Fortran, Rust, Go) whose source code is translated into machine code by a compiler before the program runs, producing a fast executable. Contrast with a scripting language, which is interpreted line by line at run time. Many fast R and Python packages are compiled C/C++ underneath. See Chapter 1. Learn more →
Compute node
A machine in an HPC cluster on which actual analysis runs. SLURM reserves CPUs, memory, and optionally GPUs on a compute node for your job after you declare your resource needs with sbatch or srun. Contrast with a login node. Learn more →
conda / mamba
Cross-language package and environment managers (conda is the original; mamba is a faster drop-in replacement) that create isolated, versioned software environments. On clusters they are used to install Python- or R-based tools that are not available as environment modules, and Bioconda uses them to distribute bioinformatics software. Learn more →
Condo node
A compute node purchased by a research group, which gets priority access to it through a dedicated partition; condo nodes supplement Talapas’s general-use nodes. See Chapter 20.
Container
A self-contained, portable package that bundles an operating system layer, runtime, and all software dependencies into a single image, ensuring the same execution environment on any host. On HPC systems, Docker images are typically run with Apptainer (.sif format). Learn more →
Container image
The immutable, versioned file (.sif for Apptainer, a layer archive for Docker) from which containers are launched. Pulling a specific image tag and keeping it on disk is a very strong reproducibility guarantee because the entire software stack is frozen at that version. Learn more →
Copilot Chat
Microsoft’s generative AI assistant, included in UO’s Microsoft 365 license. Signed in with your UO account it is a UO-protected tool approved for more than green data; unsupported AI tools may be used with green (low-risk) data only. Not to be confused with GitHub Copilot, the code assistant inside VS Code. See Chapter 3. Learn more →
Core
An independent processing unit within a CPU. A quad-core CPU can genuinely run four tasks simultaneously. R and Python use a single core by default; parallel operations require explicit setup (e.g., the R future or parallel packages, Python multiprocessing). Core count matters when you request resources for SLURM jobs that use multiple threads. Learn more →
CPU (Central Processing Unit)
The chip that executes the instructions in a program. It contains one or more cores, runs at a given clock speed, and has several layers of cache memory. For most analyses in this course the CPU is the primary compute resource; the GPU becomes relevant for deep learning, image processing, and some simulations. Learn more →
CRAN
The Comprehensive R Archive Network, the official repository for general-purpose R packages, accessed with install.packages(). Contrast with Bioconductor (biology-focused packages) and GitHub (development versions). Learn more →
CSV
Comma-Separated Values, a plain-text file format where each row is a record and columns are delimited by commas. Read into R with read_csv() (tidyverse, returns a tibble) or read.csv() (base R), and into Python with pandas.read_csv(). Preferred for small tables because it is human-readable and software-agnostic. See also TSV. Learn more →
CUDA
NVIDIA’s platform for running general computation on GPUs. On Talapas, GPU jobs typically module load cuda alongside their other software. See Chapter 20.

J.4 D

Data classification (green/amber/red)
UO’s scheme for rating data by the harm its exposure would cause. Green (low risk: published data, your code, most de-identified data) may go almost anywhere, including AI tools; amber (medium: FERPA records, unpublished research data) belongs in OneDrive, Dropbox, or Teams/SharePoint; red (high: HIPAA/protected health information, Social Security and credit-card numbers) may only be stored in approved systems. Know the class before choosing where to put data. See Chapter 3.
Data frame
R’s primary tabular data structure: a rectangular table where each column is a vector of a single type and each row is an observation. Different columns may hold different types (character, numeric, factor). Python’s pandas library provides an equivalent DataFrame. Learn more →
Diff
The line-by-line difference between two versions of a file. In Git, git diff shows unstaged changes and git diff HEAD~1 shows what changed in the most recent commit; the standalone Unix diff file1 file2 compares any two text files. Learn more →
Directed acyclic graph (DAG)
A graph of nodes connected by one-way edges with no cycles. Workflow managers such as Snakemake and Nextflow represent a pipeline as a DAG, in which each step points to the steps that depend on its output. Learn more →
Directory
A named location in the file system that can contain files and other directories (subdirectories), forming a tree structure rooted at / on Unix-like systems. Equivalent to a “folder” in graphical interfaces. Learn more →
Docker
The dominant container platform on laptops and in the cloud. Docker images can be pulled from registries such as Docker Hub or GHCR and run with Apptainer on HPC clusters, which do not allow Docker’s root-level daemon. Learn more →
DOI (Digital Object Identifier)
A permanent, citable identifier for a digital object such as a paper, dataset, or archived code release; Zenodo mints DOIs for GitHub releases. See Chapter 19.
dplyr
An R package (part of the tidyverse) providing a grammar of data manipulation: core verbs such as filter(), select(), mutate(), arrange(), group_by(), and summarise() cover most data-frame operations. All verbs work naturally with the pipe |>. Learn more →
Dropbox (UO)
A cloud file-sync service for which UO holds an institutional contract. Since March 2026 it is available to faculty, staff, and graduate employees (GEs); students who are not UO employees use OneDrive instead. Accounts have 2 TB, labs can share team folders, and it is approved for green and amber data but not for HIPAA or other red data. The desktop app creates a synced folder whose path contains spaces (~/University\ of\ Oregon\ Dropbox/), so quote it in the shell. See Chapter 3. Learn more →
Duck ID
The UO-issued university account identifier (the part of a @uoregon.edu email address before the @), used as the login name for SSH access to Talapas, for VS Code Remote-SSH connections, and with Duo two-step login. Learn more →
Duo two-step login
A two-factor authentication service: after entering your password, you approve the login on a second device (typically the Duo Mobile app on your phone). UO accounts, including Talapas SSH logins, require Duo, so set it up early (see Chapter 3). Learn more →

J.5 E

Embarrassingly parallel
Describes a task made of many independent repetitions of the same computation (bootstraps, per-sample processing, simulations), which parallelizes with essentially no coordination between workers. See Chapter 21.
Environment isolation
The practice of preventing one project’s software versions from affecting another’s, achieved on a laptop with renv, Python virtual environments, or conda, and on a cluster with environment modules, renv, or container images. It is essential on shared HPC systems where many users’ conflicting dependencies coexist. Learn more →
Environment module
A configuration file managed by Lmod that, when loaded with module load, modifies shell variables (PATH, LD_LIBRARY_PATH, etc.) to make a specific software version available. Modules are loaded per shell, so they must be reloaded at the start of every session and explicitly inside every batch job script. Learn more →
Environment variable
A named key-value pair stored in the shell’s environment that programs can read at runtime. PATH is the most important; it lists the directories the shell searches when you type a command. Set with export VAR=value; inspect with echo $VAR or env. Learn more →
Exit status
The integer code a process returns when it finishes: 0 conventionally means success and any non-zero value signals an error. Shell scripts check exit statuses to decide whether to continue (&&) or handle failures (inspect the last one with echo $?); SLURM uses the exit status to mark a job as completed or failed. Learn more →

J.6 F

Factor
An R data structure for categorical variables that stores values together with a fixed, ordered set of allowed values called levels. The first level is the reference group in statistical models, so level order matters. Created with factor(x, levels = c(...)). Learn more →
FAIR
A set of data-stewardship principles (Findable, Accessible, Interoperable, Reusable) for making research data and metadata usable by both people and machines (Wilkinson et al. 2016, https://doi.org/10.1038/sdata.2016.18). See Appendix C. Learn more →
Fair-share scheduling
A SLURM priority mechanism that tracks recent usage per research group (PIRG) and deprioritizes groups that have consumed the most resources recently, balancing cluster access over time. Combined with backfill, this means small, well-sized jobs often start sooner than large ones regardless of submission order. Learn more →
FASTA
A plain-text format for biological sequences: one header line beginning with > followed by the sequence on subsequent lines. Used for reference genomes, transcriptomes, and protein sequences; it carries no quality information (contrast with FASTQ). Count sequences with grep -c '>' file.fasta. Learn more →
FASTQ
The standard format for raw sequencing reads. Each read occupies four lines: an @ identifier, the sequence, a + separator, and per-base quality scores encoded as ASCII characters (Phred scores). Usually stored gzip-compressed (.fastq.gz). Learn more →
FERPA
The Family Educational Rights and Privacy Act, the US federal law protecting student education records. At UO, FERPA data is classified amber and may be kept in OneDrive, UO Dropbox, or Teams/SharePoint. See Chapter 3. Learn more →
File permissions
Access-control rules on a Unix file system that specify what each class of user (owner, group, others) may do with a file: read (r), write (w), and execute (x). Displayed by ls -l; changed with chmod (e.g., chmod +x script.sh makes a shell script executable). Also useful for protecting raw data from accidental overwriting. Learn more →
File system
The component of an operating system that organizes files into a hierarchical tree of directories, manages storage on disk, and enforces file permissions. Unix/Linux uses a single tree rooted at /; Windows uses drive-letter roots such as C:\. Learn more →
Firmware
Low-level software stored directly in a hardware component (a disk controller, network card, or the computer’s boot ROM) that provides its basic control functions. It sits between the physical hardware and the operating system and is updated rarely, usually by the manufacturer. See Chapter 4. Learn more →
Flag / option
A modifier passed to a shell command that changes its behavior, typically prefixed with - (short form, e.g., -l) or -- (long form, e.g., --help). Flags are distinct from arguments: a flag controls how the command runs, while an argument specifies what it acts on. Learn more →
Function
A named, reusable block of code that takes arguments, performs a computation, and returns a result. In R, defined with name <- function(args) { body } (the last evaluated expression is returned); in Python, with def name(args): and return. Learn more →
future / furrr
The R package ecosystem for parallel computing used in this course: future sets the plan (how work is distributed), and furrr provides parallel drop-in versions of purrr’s map() functions (future_map()). See Chapter 21.

J.7 G

Gene Expression Omnibus (GEO)
NCBI’s public repository for processed functional-genomics data (expression tables, sample metadata) from microarray and sequencing studies, organized under GSE###### series accessions. See Appendix C. Learn more →
GFF3 / GTF
Tab-delimited, nine-column annotation formats describing genomic features (genes, transcripts, exons, coding sequences) on a reference genome. GTF is the older format still required by many aligners and quantifiers; GFF3 is the modern, fully specified format used by Ensembl and NCBI. Chromosome names must match the reference FASTA and any aligned BAM. Learn more →
ggplot2
An R package implementing the grammar of graphics: plots are built by specifying a data frame, aesthetic mappings (aes()), and geometric layers (geom_point(), geom_boxplot(), etc.) connected with +. A standard tool for publication-quality figures. Learn more →
Git
The free, open-source, distributed version control system that records the history of a project as a series of commits. Every copy of a Git repository contains the full history, and changes are shared with collaborators through remotes such as GitHub. See Chapter 19. Learn more →
GitHub
A web-based hosting service for Git repositories that adds collaboration features (pull requests, issues, code review, Actions for automation, and GitHub Pages) and provides cloud backup for version-controlled projects. Learn more →
GitHub Pages
A free static-site hosting service built into GitHub that serves HTML files directly from a repository branch or /docs folder. Quarto renders .qmd files to HTML, which GitHub Pages publishes as a website at https://username.github.io/repo. Learn more →
.gitignore
A plain-text file in a Git repository that lists file patterns (e.g., *.fastq.gz, .Rhistory, .DS_Store) Git should never track; essential for keeping large data files, credentials, and temporary outputs out of version control. Learn more →
Globus
A service for fast, reliable transfer of very large datasets between institutions and storage systems, with automatic retries and checksum verification. RACS provides Globus endpoints for Talapas, making it the right tool for moving terabytes from a sequencing core or a collaborator, where scp would be slow and fragile. See Chapter 3. Learn more →
GPU (Graphics Processing Unit)
A processor with thousands of small, simple cores designed for massive data parallelism rather than sequential logic. Important for deep learning, image analysis, and many physics-based simulations; most command-line and R work in this course runs entirely on the CPU. Learn more →
grep
A Unix command-line tool that searches files or input streams for lines matching a pattern; the name stands for “global regular expression print.” Supports literal strings and regular expressions; -v inverts the match, -c counts matching lines, -i ignores case, and -n shows line numbers. Covered in Lecture 03 and Chapter 9. Learn more →
GUI (Graphical User Interface)
A point-and-click visual interface to a computer, as opposed to a command line. Many scientific analyses are done with scripts rather than GUIs because GUI steps cannot easily be recorded, version-controlled, repeated, or run unattended on an HPC cluster. Learn more →

J.8 H

Hallucination (LLM)
A fluent, confident, and false output from a large language model, such as a function, package, or argument that does not exist. The defense is reading the code and testing it on an input whose answer you know. See Chapter 18.
HDD (Hard Disk Drive)
A mechanical spinning-platter storage device with high capacity and low cost per gigabyte but relatively high access latency (~10 ms) compared to an SSD. Common for archival storage and large network-attached storage on servers. Learn more →
HDF5 / H5
Hierarchical Data Format version 5, a binary file format that organizes data into a filesystem-like hierarchy of groups and datasets, supports compression, and allows reading just part of a file without loading all of it. Used for large numerical arrays in imaging, simulation, and genomics (e.g., .h5 and AnnData .h5ad files). Learn more →
Here document
A shell construct that feeds several lines of text to a command’s stdin directly from the script, between <<EOF and a closing EOF line. Useful for writing a small configuration file or passing a multi-line query to a program without creating a separate file. Learn more →
Hidden file (dotfile)
A file or directory whose name begins with a period (.bashrc, .gitignore, .venv, .config/). Unix tools hide these from ls and wildcards by default; ls -a shows them. They usually hold settings, so they are hidden to reduce clutter, not for security. Learn more →
HIPAA
The Health Insurance Portability and Accountability Act, the US federal law governing protected health information (PHI). At UO, PHI is red data: it may live only in approved systems (UO OneDrive and Teams are approved, Dropbox is not), never in personal cloud accounts, email attachments, or unsupported AI tools. See Chapter 3. Learn more →
Home directory
The personal directory assigned to each user on a Unix system, typically /home/username on Linux or /Users/username on macOS. Abbreviated ~ in shell paths. Your shell starts here by default, and configuration files such as .bashrc live here. Learn more →
HPC (high-performance computing)
The use of clusters of powerful, networked computers (with many CPU cores, large RAM, and sometimes GPUs) to run analyses that exceed a single laptop’s capacity in memory or time. The University of Oregon’s HPC cluster is Talapas, managed by RACS. Learn more →
HPC cluster
A network of individual machines (nodes) sharing a parallel filesystem and managed as a single system by a scheduler such as SLURM. Users log in to login nodes to edit files and submit jobs, which the scheduler routes to available compute nodes. Learn more →

J.9 I

IDE (Integrated Development Environment)
A software application that bundles a code editor, console or terminal, debugger, and version-control interface into one window. VS Code, Positron, and RStudio are the IDEs used in this course; all provide syntax highlighting, code completion, and an integrated terminal. Learn more →
install.packages() vs library()
A key distinction for R beginners: install.packages("pkg") downloads and installs a package onto your machine (do this once; use BiocManager::install() for Bioconductor packages); library(pkg) loads an already-installed package into the current R session (do this every session). Restarting R requires re-loading but not re-installing. Learn more →
Interactive session
A live shell running on a compute node, obtained via srun --pty bash or salloc, in which commands are typed and output appears immediately. Appropriate for testing scripts, debugging, and short exploratory runs; the node stays reserved whether or not you are typing, so exit as soon as you are done. Contrast with a batch job. Learn more →
IRB (Institutional Review Board)
The committee that reviews and approves research involving human participants. Any data collected under an IRB protocol is human-subjects data, treated as red (high-risk) at UO: store it only where the protocol and UO approve, de-identify it as early as possible, and keep the linking key separately. See Chapter 3. Learn more →

J.10 J

Job
A unit of work submitted to the SLURM scheduler, consisting of a resource declaration (--cpus-per-task, --mem, --time, --account) and the commands to run. Each job receives a unique job ID and runs on a reserved compute node. Learn more →
Job array
A SLURM mechanism (#SBATCH --array=1-N) that submits N independent sub-jobs from a single script, each receiving a unique $SLURM_ARRAY_TASK_ID. It is the standard pattern for per-sample parallel work (e.g., processing 24 image stacks or 24 sequencing samples) without writing N separate scripts; --array=1-N%M caps the number running at once at M. Learn more →
Job ID
The unique integer SLURM assigns to every submitted job (printed as Submitted batch job 123456); used to check status with squeue -j <id>, cancel with scancel <id>, and review resource usage after completion with seff <id> and sacct -j <id>. Learn more →
JSON
JavaScript Object Notation, a lightweight, human-readable text format for structured data built from key-value pairs ({"sample": "S1", "temp_C": 37}) and lists ([1, 2, 3]). Common for configuration files, pipeline parameters, and web APIs; read in R with jsonlite and in Python with the built-in json module. Learn more →
Jupyter notebook
An interactive document (.ipynb) that mixes code cells, their outputs, and Markdown text, run in a web browser or IDE through a language kernel (most often Python). A popular form of literate programming; Quarto can render .ipynb files and can use Jupyter to execute Python code. Learn more →

J.11 K

Kernel
  1. The core of an operating system that runs with full hardware privileges and manages all resources: CPU scheduling, memory allocation, device drivers, and the file system. User programs interact with the kernel through system calls rather than touching hardware directly. (2) In Jupyter, the background process (e.g., a Python or R interpreter) that executes a notebook’s code. Learn more →
knitr
The R-based engine that executes {r} code chunks when Quarto (or R Markdown) renders a document; Python chunks run through Jupyter instead. See Chapter 16.

J.12 L

Large language model (LLM)
A statistical model trained on enormous amounts of text (including code) that generates the most plausible continuation of a prompt. The basis of AI coding assistants; plausible is not the same as correct. See Chapter 18.
LaTeX
A typesetting system widely used for scientific documents, especially those with mathematical equations. Quarto uses LaTeX to produce PDF output, and LaTeX math syntax (e.g., $E = mc^2$) also works inside Markdown documents rendered to HTML. See also TinyTeX. Learn more →
Library (R)
The folder on your computer where installed R packages live (see .libPaths()). The library() function loads a package from that folder into the current session. Learn more →
list (R)
R’s most flexible data container: each element can hold any type of object (a vector, a data frame, another list, a function), and elements need not be the same length or type. Many complex R objects (e.g., model fits) are lists under the hood. Access named elements with $name or [["name"]] and by position with [[i]]. Learn more →
Literate programming
A style of writing where code and prose explanation are interleaved in the same document, so the document itself is both a readable narrative and an executable program. Quarto .qmd files and Jupyter notebooks implement literate programming. Learn more →
Lmod
The hierarchical environment-module system used on Talapas (and most modern HPC clusters) to manage centrally installed software. Key commands: module spider <name> (find available versions), module avail (list loadable modules), module load <name>/<version> (activate software), module list (show loaded modules), and module purge (reset). Learn more →
Lockfile
A file (e.g., renv.lock for renv) that records the exact name, version, and source of every package in a project’s software environment so the same environment can be rebuilt on any machine. Commit the lockfile (but not the package library itself) to Git. Learn more →
Login node
The shared gateway machine you land on when you SSH into a cluster (login.talapas.uoregon.edu). It is meant only for editing files, running short commands, and submitting jobs, never for heavy computation, because all users share it at the same time. The VS Code Remote-SSH integrated terminal also opens on a login node. Learn more →

J.13 M

Markdown
A lightweight plain-text formatting language that converts simple syntax (e.g., **bold**, # Heading, `code`) into formatted HTML or PDF. Quarto documents, GitHub README files, and this glossary are all written in Markdown. See Chapter 16. Learn more →
Merge
The Git operation that integrates changes from one branch into another, often creating a merge commit that unifies both histories; the final step in a feature-branch workflow. When both branches changed the same lines, Git reports a merge conflict for you to resolve by hand. Learn more →
Microsoft 365
Microsoft’s cloud-based productivity suite (Word, Excel, PowerPoint, Outlook, Teams, and OneDrive storage). See Chapter 3 for how to access university-provided software with your UO account. When using Excel for scientific data, keep a plain-text CSV copy (see Appendix C). Learn more →

J.14 N

Nextflow
A workflow manager that represents a pipeline as a dataflow graph, automatically re-running only the stages whose inputs changed, parallelizing independent steps, and integrating with containers, HPC schedulers, and cloud executors. A natural upgrade from hand-written shell scripts once a pipeline must process many samples. Learn more →

J.15 O

OneDrive
Microsoft’s cloud file storage and sync service, part of Microsoft 365. Handy for documents and backups, but synced folders are a poor place for Git repositories or large, frequently changing data files, because the sync client can conflict with rapidly changing files. UO provides 1 TB per person; see Chapter 3. Learn more →
Open OnDemand
A web portal (ondemand.talapas.uoregon.edu) provided by RACS that gives browser-based access to Talapas, including a file browser and interactive application sessions (RStudio, JupyterLab, a full desktop) without requiring an SSH client. Sessions run as jobs on compute nodes and keep running after you close the browser. See Chapter 3. Learn more →
Open VSX
An open, vendor-neutral registry of editor extensions. Positron installs its extensions from Open VSX rather than from Microsoft’s Visual Studio Marketplace, so a few Microsoft-only extensions are unavailable there (Positron supplies its own equivalents). See Chapter 2. Learn more →
Operating system (OS)
System software, such as Linux, macOS, or Windows, that manages hardware resources (CPU, memory, storage, I/O) and provides the environment in which user programs run. Research computing clusters, including Talapas, run Linux; macOS and Linux share a Unix heritage that makes shell skills transferable between them. Learn more →

J.16 P

Package
A bundled collection of functions, data, and documentation that extends a language. R packages are installed from CRAN (install.packages()) or Bioconductor (BiocManager::install()) and loaded each session with library(); Python packages are installed with pip or conda and loaded with import. Learn more →
Pandoc
A universal document converter that translates between Markdown, HTML, Word (.docx), LaTeX, PDF, and many other formats. Quarto bundles Pandoc and uses it behind the scenes to turn your .qmd files into finished documents. Learn more →
Parallel filesystem
A shared, high-bandwidth storage system visible identically from every login node and compute node in a cluster, so files written on one node are immediately readable on another. Learn more →
Partition
A SLURM grouping of nodes by hardware class and maximum run time. Every job targets a partition (e.g., compute, computelong, gpu, memory, interactive) that matches its hardware needs and duration; run sinfo to see partition states and node availability. Learn more →
PATH
An environment variable containing a colon-separated list of directories the shell searches when you type a command name. When you type R, the shell walks the directories in PATH until it finds an executable named R. A misconfigured PATH is a common source of “command not found” errors; inspect it with echo $PATH. Learn more →
Pipe (R |>)
The native R pipe operator (introduced in R 4.1; the older magrittr pipe %>% also works) that passes the result of the left-hand expression as the first argument of the right-hand expression, enabling left-to-right chains such as df |> filter(temp > 37) |> summarise(mean(force)). Learn more →
Pipe (shell |)
The Unix mechanism for connecting the stdout of one command to the stdin of the next, all in memory with no temporary file written to disk, e.g., grep "^>" seqs.fasta | sort | uniq | wc -l. Fundamental to the Unix philosophy of chaining small, focused tools. Learn more →
Pipeline
Also called a workflow. A pre-specified series of steps that are executed in order, where each step’s output feeds the next. Learn more →
PIRG (Principal Investigator Research Group)
The account unit on Talapas representing a research group. It is required in every SLURM job submission as --account=<PIRG> for usage tracking and fair-share accounting; a PI requests the group and adds members. See Chapter 3. Learn more →
Positron
A free, next-generation data-science IDE from Posit (the makers of RStudio), built on Code OSS, the open-source core of VS Code. It supports both R and Python with a console, variables pane, plots pane, and data viewer, and accepts many VS Code extensions. Learn more →
Process
A running instance of a program. The operating system gives each process a slice of CPU time, a private region of RAM, and its user’s file permissions. Running R in a terminal starts an R process; ps and top list running processes. On a shared cluster, many users’ processes coexist and are managed by a scheduler. Learn more →
Project storage
The /projects/<PIRG>/ filesystem on Talapas, providing shared storage for a research group. It is the right place for shared datasets, analysis code, and final outputs that should persist (unlike scratch space). Learn more →
Pull
The Git operation (git pull) that downloads commits from a remote repository and merges them into the current local branch; equivalent to git fetch followed by git merge. Learn more →
Pull request
A GitHub feature that formally proposes merging one branch into another. It provides a structured interface for code review, discussion, and automated checks before the changes are integrated. Learn more →
Push
The Git operation (git push) that uploads local commits to a remote repository, making them available to collaborators and backing up your work. Learn more →
Python
A free, general-purpose, interpreted programming language widely used in data science, machine learning, image analysis, and instrument control. Key scientific libraries include NumPy, pandas, SciPy, matplotlib, and scikit-learn. Runs in scripts, the interactive REPL, Jupyter notebooks, and Quarto documents. Learn more →

J.17 Q

QOS (quality of service)
A SLURM limit layer that caps how much one user or group can use at once (e.g., maximum running jobs or total cores). When a job sits in the queue with a reason like QOSMaxJobsPerUserLimit, earlier jobs must finish before the next starts; no action is needed beyond waiting. Learn more →
Quarto
An open-source scientific publishing system (successor to R Markdown) that renders plain-text .qmd files, mixing Markdown prose, R/Python/Bash code chunks, and their outputs, into HTML, PDF, Word, slides, or whole websites. This course website is built with Quarto. See Chapter 16. Learn more →
Queue
The ordered list of jobs waiting to run on a scheduler. Jobs enter when submitted with sbatch and leave when SLURM finds matching resources; monitor your jobs with squeue -u $USER. Priority is set by fair-share scheduling. Learn more →

J.18 R

R
A free, open-source language and environment for statistical computing and graphics, extended by thousands of packages from CRAN and Bioconductor. Usually used through an IDE such as Positron or RStudio. Covered in Lecture 05 and Chapter 11. Learn more →
RACS (Research Advanced Computing Services)
The University of Oregon unit that manages the Talapas HPC cluster, handles account requests, provides documentation in the Talapas Knowledge Base, and offers user support. Learn more →
RAM (Random Access Memory)
Fast, volatile working memory that holds the data and code the CPU is actively using. Data must fit in RAM while being analyzed: a large 3D microscopy stack or a high-resolution simulation output can easily need 10-50 GB. “Out of memory” errors mean the data exceeds available RAM. Contrast with disk storage (SSD, HDD). Learn more →
RDS
R Data Serialization, R’s native binary format for saving a single R object to disk with saveRDS() and reloading it with readRDS(). RDS files preserve an object exactly and are convenient for hand-offs between analysis steps, but are readable only by R, so use plain-text formats such as CSV for sharing and archiving. Learn more →
Regular expression (regex)
A pattern language for matching text using metacharacters such as . (any character), * (zero or more), ^ (start of line), and $ (end of line). Understood by tools like grep, sed, R’s grepl() and stringr functions, and Python’s re module. See Chapter 9. Learn more →
Relative path
A file path interpreted relative to the current working directory, e.g., ../data/measurements.csv (up one level, then into data/). Relative paths are shorter and keep working when a whole project folder is moved, so they are preferred in analysis scripts for reproducibility. Contrast with absolute path. Learn more →
Remote
In Git, a named reference to a copy of a repository hosted elsewhere (typically GitHub). origin is the conventional name for the primary remote, and git push / git pull synchronize local and remote histories. Learn more →
Remote-SSH (VS Code)
A VS Code extension that connects the editor to a remote host over SSH so that the file browser, editor panes, and integrated terminal all operate on the remote machine. When connected to Talapas, the status bar shows SSH: login.talapas.uoregon.edu and shell commands run on the login node. Learn more →
Rendering
The process by which Quarto executes all code chunks in a .qmd file, weaves the output into the document, and produces the final HTML, PDF, or slides. Triggered with quarto render or the Render/Preview button in RStudio, Positron, or VS Code. Learn more →
renv
An R package that records a per-project snapshot of every installed package and its version in an renv.lock file. renv::snapshot() updates the lockfile after you add packages; renv::restore() rebuilds the identical library on any machine (laptop or Talapas). Learn more →
REPL (Read-Eval-Print Loop)
An interactive programming environment that reads one expression at a time, evaluates it, prints the result, and waits for the next input. The R console, the Python >>> prompt, and the shell itself are all REPLs; they let you experiment line by line before saving code to a script. Learn more →
Repository
The directory, tracked by Git, that stores a project’s files together with the complete history of all commits, branches, and tags. A local repository can be linked to one or more remote repositories. (Public data repositories such as GEO are a different sense of the word; see Appendix C.) Learn more →
Reproducibility
The property of an analysis whereby a second person (or you, later) can re-run every step from raw data to final figures using only the recorded code, data, and software versions. Literate programming with Quarto, version control with Git, and consistent file organization all contribute. Learn more →
Reproducible computing
The practice of capturing the exact software environment, code, data, and parameters needed to reproduce a result, usually in layers: renv lockfiles or conda environment files pin package versions, container images pin the OS and system libraries, and environment modules select tool versions on a cluster. Learn more →
reticulate
The R package that lets the knitr engine run {python} chunks inside an otherwise-R Quarto document, with objects shared between the languages as py$x (in R) and r.x (in Python). See Section 16.5.
RStudio
An IDE purpose-built for R (from Posit), with a Source pane (script editor), Console pane (live R session), Environment/History pane, and Files/Plots/Packages/Help pane. Writing code in the Source pane rather than the Console keeps it saved and reproducible. Optional in this course alongside Positron and VS Code; also available on Talapas through Open OnDemand. See Section 2.6. Learn more →

J.19 S

sacct
A SLURM command that queries the accounting database for job statistics after completion (e.g., sacct -j 123456 --format=JobID,ReqMem,MaxRSS,Elapsed,State,ExitCode); useful for finding peak memory (MaxRSS) and run time (Elapsed) to right-size future jobs. Learn more →
SAM
Sequence Alignment/Map, a tab-delimited text format that stores how sequencing reads map to a reference genome. Each line is one read alignment with its sequence, base qualities, mapping position, and mapping quality. BAM is its compressed binary form. Learn more →
sbatch
The SLURM command to submit a batch job script to the scheduler; it returns a job ID (Submitted batch job 123456). The script’s #SBATCH directives declare resource needs, and the job runs unattended on a compute node. Learn more →
#SBATCH directive
A comment-formatted instruction in a batch script (e.g., #SBATCH --mem=16G) that SLURM reads to set resource requirements and job metadata. All directives must appear at the top of the script, before any commands. Learn more →
scancel
The SLURM command to cancel a queued or running job by job ID (scancel 123456) or in bulk (scancel -u $USER cancels all of your jobs). Learn more →
Scheduler
Software that turns user resource requests (CPUs, memory, time, GPUs) into reservations on specific compute nodes, sharing a cluster fairly among many simultaneous users. SLURM is the scheduler on Talapas and most academic HPC systems. Learn more →
Scratch space
Large, high-throughput working storage on a cluster for intermediate files and temporary outputs. On Talapas it is not backed up and old files are purged automatically, so use it only for transient data, never for scripts or final results. Check the Talapas Knowledge Base for current policies. Learn more →
Scripting language
A programming language that is interpreted at runtime rather than compiled ahead of time, making it fast to write and iterate. Bash, R, and Python are all scripting languages. Learn more →
seff
A SLURM utility (installed on most clusters, including Talapas) that prints a friendly summary of a completed job’s CPU efficiency, memory efficiency, and wall time: seff <jobid>. The quickest way to right-size future submissions. Learn more →
Sequence Read Archive (SRA)
NCBI’s repository for raw sequencing reads (FASTQ/BAM), linked to GEO series through BioProject and BioSample accessions. Downloaded with sra-tools (prefetch + fasterq-dump) or from the European mirror (ENA). See Appendix C. Learn more →
Shell
A command interpreter that accepts text commands, passes them to the operating system, and returns output as text. Bash and zsh (the default on modern macOS) are the most common shells for scientific computing. The shell is also a scripting language: commands saved in a .sh file can be re-run non-interactively. Learn more →
Shell script
A text file of shell commands, usually starting with a shebang line (e.g., #!/bin/bash), that can be executed as a program. Shell scripts automate repetitive tasks, chain analysis steps into pipelines, and serve as the job scripts submitted to SLURM. Covered in Lecture 04 and Chapter 10. Learn more →
SLURM
The Simple Linux Utility for Resource Management, the scheduler used on Talapas and most academic HPC clusters. It accepts job submissions (sbatch, srun), places jobs on appropriate compute nodes, enforces resource limits (--mem, --time), and provides accounting (sacct, seff). Covered in Lecture 08. Learn more →
SLURM commands (quick list)
sbatch (submit a batch script), srun (run a command or interactive shell), squeue -u $USER (list your jobs), scancel <id> (cancel), sinfo (partition status), sacct and seff (usage after a job ends). Each has its own entry in this glossary. Learn more →
Snakemake
A Python-based workflow manager that describes a pipeline as rules with input: and output: files, automatically re-running only rules whose inputs have changed and running independent rules in parallel. A natural upgrade from shell scripts for pipelines that process many samples or must restart after partial failures. Learn more →
Sparse matrix
A storage format for matrices that are mostly zeros. Instead of keeping every zero, a sparse matrix saves only the non-zero values and their positions, saving memory and speeding up calculations (e.g., the R Matrix package, Python scipy.sparse). Learn more →
squeue
The SLURM command to list queued and running jobs. squeue -u $USER shows your jobs with state codes (PD pending, R running, CG completing) and a Reason column explaining why pending jobs have not started. Finished jobs disappear from squeue; use seff or sacct afterward. Learn more →
srun
The SLURM command to launch a job step or start an interactive session on a compute node; srun --pty bash (with --account, --partition, --mem, and --time flags) requests an interactive shell. Learn more →
SSD (Solid-State Drive)
A storage device that uses flash memory with no moving parts, offering much lower access latency (~0.1 ms) and higher throughput than an HDD. Keeping large input files on an SSD noticeably speeds up loading them. Learn more →
SSH (Secure Shell)
A cryptographic network protocol for authenticated, encrypted remote login. On Talapas, ssh <duckid>@login.talapas.uoregon.edu opens a shell on a login node, and VS Code Remote-SSH uses the same protocol to connect the editor to the cluster. Learn more →
SSH key
A cryptographic key pair (public + private) that authenticates SSH connections without typing a password. Generate one with ssh-keygen -t ed25519; the public key (~/.ssh/id_ed25519.pub) is copied to a server or added to GitHub, while the private key never leaves your computer. Learn more →
SSH tunneling
Forwarding a network port from a remote server through an encrypted SSH connection to your local machine (e.g., ssh -L 8888:localhost:8888 ...), commonly used to reach a Jupyter or RStudio server running on a compute node from a local web browser. Learn more →
Staging area
In Git, the intermediate zone (also called the index) where changes are placed with git add before being recorded in a commit. It lets you package related changes into logically coherent commits rather than committing every modified file at once. Learn more →
stdin / stdout / stderr
The three standard streams every Unix process inherits: stdin (stream 0) is input (keyboard or a redirected file with <); stdout (stream 1) is normal output (terminal, or a file with >); stderr (stream 2) carries error and status messages (redirected separately with 2>). Pipes connect stdout of one command to stdin of the next. Learn more →
Symbolic link
A filesystem entry that points to another file or directory rather than containing data itself, like a desktop shortcut. Created with ln -s target linkname; on clusters, symlinks give projects easy access to shared reference data without duplicating large files. Learn more →
Syntax highlighting
The automatic coloring of different parts of source code (keywords, strings, comments, function names) in a code editor. RStudio, Positron, and VS Code highlight R, Python, Bash, and Quarto documents, making code easier to read and errors easier to spot. Learn more →

J.20 T

tabix
A tool from the htslib suite that indexes a coordinate-sorted, BGZF-compressed tab-delimited file (VCF, BED, GFF) so you can quickly pull out the lines for a genomic region without scanning the whole file. Learn more →
Tag
In Git, a named, fixed reference to a specific commit, most often used to mark releases (e.g., v1.0). Unlike branches, tags do not move as new commits are added, making them good for citing the exact version of code used in a paper. Learn more →
Talapas
The University of Oregon’s HPC cluster, managed by RACS. It provides thousands of CPU cores, GPUs, and large shared storage, and is accessed via SSH or Open OnDemand using your Duck ID and Duo two-step login. Covered in Chapter 20. Learn more →
Teams / SharePoint
Microsoft’s group collaboration tools within Microsoft 365. Teams provides chat, meetings, and shared files for a lab or class; the files behind a Team live in SharePoint, storage owned by the group rather than by any one person, which makes it the right home for lab documents that must outlast individual members. Approved at UO for amber and, like OneDrive, HIPAA data. See Chapter 3. Learn more →
Template repository
A GitHub repository marked as a template: “Use this template” gives you a fresh repository with the template’s files but no shared history and no upstream connection, unlike a fork. See Chapter 19.
Terminal
An application that provides a text window in which you interact with a shell. On macOS the built-in app is Terminal; on Windows, WSL provides an Ubuntu terminal; RStudio, Positron, and VS Code all have a built-in terminal. “Terminal” and “command line” are often used interchangeably. Learn more →
Text editor
A program for creating and editing plain-text files without the hidden formatting of word processors. Simple editors (nano, vim) run in a terminal; feature-rich editors (VS Code, Positron, RStudio) add syntax highlighting, autocompletion, and Git integration. R scripts, shell scripts, and .qmd files are all plain text. Learn more →
tibble
An enhanced data frame from the tibble package (part of the tidyverse) that prints more concisely, never converts strings to factors, and gives clearer error messages. read_csv() returns a tibble; as_tibble() converts an existing data frame. Learn more →
tidyverse
A collection of R packages (including dplyr, ggplot2, tidyr, readr, purrr, and tibble) built around a consistent, pipe-friendly grammar for data import, tidying, transformation, and visualization. Loaded with library(tidyverse). Learn more →
TinyTeX
A lightweight, easy-to-maintain LaTeX distribution designed for R Markdown and Quarto users. Install it with quarto install tinytex so Quarto can render PDF documents; missing LaTeX packages are installed automatically as needed. Learn more →
TSV
Tab-Separated Values, a plain-text format like CSV but using tab characters as delimiters. Common for genomics tables and annotation files because text fields may themselves contain commas. Read with read_tsv() in the tidyverse or pandas.read_csv(sep="\t") in Python. Learn more →

J.21 V

VCF (Variant Call Format)
A tab-delimited format for genomic variant calls (SNVs, indels, structural variants) relative to a reference, with a ## metadata header, mandatory columns (CHROM, POS, ID, REF, ALT, QUAL, FILTER, INFO), and optional per-sample genotype columns. BCF is its binary equivalent. Learn more →
Vector
R’s fundamental data structure: an ordered sequence of values that are all the same type (numeric, character, logical). Most R operations are vectorized, applying element-wise to every value at once. Learn more →
Vectorization
The property of R (and NumPy in Python) whereby operations automatically apply element-wise to every element of a vector or column, with no explicit loop. For example, force_N > 4 tests every element of force_N in one expression. Vectorized code is shorter and usually much faster than loops. Learn more →
Version control
The practice of systematically tracking changes to files over time so that earlier states can be recovered, alternative versions developed in parallel branches, and contributions from collaborators merged. Git is the dominant version-control system in science and engineering. Learn more →
Vibe coding
Programming by describing what you want to an AI assistant and accepting what comes back without reading it. Fast for throwaway projects; unacceptable for science, where you must be able to defend every result. See Chapter 18.
Virtual environment
An isolated set of installed packages for one project, so that different projects can use different package versions without interfering. In Python, python3 -m venv .venv creates one and source .venv/bin/activate turns it on; conda and uv are alternatives, and renv plays the same role in R. Standard practice on Talapas. See Chapter 2. Learn more →
Virtual machine (VM)
A software emulation of an entire computer (hardware, operating system, and installed programs) that runs inside a host computer. VMs can run Linux on a Windows or Mac laptop; WSL uses a lightweight VM, and containers are an even lighter-weight alternative. Learn more →
VPN (Virtual Private Network)
An encrypted connection between your computer and an organization’s network that makes your traffic appear to come from inside that network. Some university resources may require a VPN connection when you work off campus; see Chapter 3 and the UO IT documentation for current guidance; for Talapas the VPN is recommended but not required. Learn more →
VS Code (Visual Studio Code)
A free, cross-platform code editor and IDE from Microsoft, built on the open-source Code OSS project, that supports R, Python, Bash, and Quarto through extensions. It includes syntax highlighting, autocompletion, Git integration, an integrated terminal, and Remote-SSH for working on Talapas. See Chapter 5. Learn more →

J.22 W

Wall-clock time vs CPU time
Wall-clock time is elapsed real time, which is what --time limits and what seff reports as “Job Wall-clock time.” CPU time is roughly wall-clock time × cores used and measures total processor work: a 1-hour job on 8 cores consumes about 8 CPU-hours but 1 hour of walltime. Learn more →
Walltime / time limit
The maximum elapsed time a SLURM job may run, set with --time=HH:MM:SS (or D-HH:MM:SS). When the limit is reached SLURM terminates the job with state TIMEOUT, so leave a reasonable margin. Learn more →
wget / curl
Command-line tools for downloading files from URLs. wget URL saves the file to the current directory; curl -L -o filename URL saves to a named file. Both pull reference genomes, datasets, and software directly onto a server or cluster without a browser. Learn more →
Wildcard / globbing
Patterns that the shell expands into matching filenames before passing them to a command: * matches any string, ? matches one character, and [abc] matches one character from the set. For example, ls *.csv lists all CSV files. “Globbing” is the name for this expansion. Learn more →
Workflow manager
A tool (Snakemake, Nextflow) that represents a computational pipeline as a dependency graph (DAG) of inputs and outputs, tracking which steps are complete, skipping finished stages, and rerunning only affected steps when inputs change. A more robust alternative to hand-written shell scripts for multi-sample pipelines. Learn more →
Working directory
The directory a process is currently “standing in,” used as the starting point for relative paths. In the shell, pwd prints it and cd changes it; in R, getwd() and setwd(); in Python, os.getcwd(). Learn more →
WSL (Windows Subsystem for Linux)
A Windows feature that runs a real Linux environment (Ubuntu by default) directly on Windows, giving you a Bash shell and Linux tools without a separate computer or dual-boot. Install it with wsl --install in an administrator PowerShell window; your Windows files appear under /mnt/c/Users/<name>. See Chapter 5. Learn more →

J.23 Y

YAML header
The block of configuration at the top of a Quarto .qmd file, delimited by --- lines and written in YAML (a recursive acronym for “YAML Ain’t Markup Language”). It sets the document title, author, output format, and execution options (e.g., eval: false). YAML is also used for many configuration files, including Quarto’s _quarto.yml. Learn more →

J.24 Z

Zenodo
A free research archive that integrates with GitHub: connecting a repository turns each release into an archived, citable copy with a DOI. See Chapter 19.
Zotero
A free, open-source reference manager. Its browser connector saves a paper’s citation and PDF with one click, group libraries share a reading list with a lab, and it inserts citations and bibliographies into Word and Quarto documents. See Chapter 3. Learn more →

A few general definitions (e.g., Algorithm, Benchmark, Pipeline, Sparse matrix) are adapted, with modifications, from the Single-cell best practices glossary (Heumos et al.). All other entries were written for this course.