Glossary

A working glossary of terms used throughout this workshop, spanning single-cell biology and analysis as well as the computing, command-line, R, and high-performance-computing concepts introduced in the foundational and Talapas modules. Many biological definitions are adapted from the Single-cell best practices glossary (Heumos et al.) and expanded where useful; the computing, command-line, R/RStudio, and HPC entries were written for this workshop.

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/wcresko/scRNAseq_tutorial/data/counts.rds. Contrast with relative path. Learn more →
Adapter sequences: Short, synthetic DNA or RNA sequences that are ligated to the ends of DNA or RNA fragments during library preparation for sequencing. Adapters are essential for binding fragments to the flowcell and enabling amplification and sequencing. If adapters are not trimmed after sequencing, they can appear in the reads and interfere with alignment and downstream analyses. Learn more →
Algorithm: A pre-defined set of instructions to solve a problem. Learn more →
Ambient RNA: Cell-free mRNA floating in the cell suspension that gets captured alongside a cell’s own transcripts, contaminating its expression profile. Tools such as SoupX or DecontX estimate and subtract it. Learn more →
Amplification bias: A distortion that occurs during DNA or RNA amplification (e.g., PCR), where certain sequences are copied more efficiently than others. Amplification bias can lead to uneven or inaccurate representation of the original genetic material, affecting results in experiments like sequencing or gene expression analysis. Learn more →
Anchors: Pairs of mutually corresponding cells identified across datasets during integration (Seurat CCA/RPCA). Anchors define the correspondences used to compute correction vectors that align batches before joint clustering. Learn more →
AnnData: A Python package for handling annotated data matrices, commonly used in single-cell and other omics analyses. AnnData stores data as a matrix where rows (observations) and columns (features) can have associated metadata and supports slicing, subsetting, and saving to disk in formats like H5AD and Zarr.
Annotation: Adding labels to raw data to provide context and make it interpretable. Gene annotation labels genes with information like function, location, and associated proteins. Cell annotation classifies cells based on type, state, or function. Biological data can be annotated in many additional ways (e.g., based on batch, disease, sex). Learn more →
Apptainer: The HPC-safe successor to Singularity that runs OCI/Docker container images on shared clusters without requiring root; on Talapas it is loaded with module load apptainer and used to apptainer pull an image from Docker Hub and then apptainer exec <image.sif> Rscript ... inside a batch job, giving stronger environment isolation than renv 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 are preferred in scRNA-seq code because function signatures are long. In the shell, arguments follow the command name after any flags, e.g., grep "ACGT" sequences.txt. Learn more →
Azimuth: A Seurat-based pipeline that annotates query cells by mapping them onto a curated, well-annotated reference (anchor-based label transfer), returning cell-type labels at several resolutions plus per-cell mapping and prediction scores. Learn more →

B

Backfill: A complementary SLURM 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 not only is polite cluster etiquette but also results in faster queue placement. Learn more →
BAM: Binary, compressed versions of SAM (Sequence Alignment/Map) files that store sequencing read alignments to a reference genome. BAM files contain the same information as SAM files — read sequences, quality scores, and alignment positions — but in a space-efficient format that enables faster processing and reduced storage requirements. Learn more →
Barcode: Short DNA barcode fragments (“tags”) used to identify reads originating from the same cell. Reads are grouped by their barcode during raw data processing. 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 and on an HPC cluster such as Talapas. Learn more →
Batch effect: Technical confounding factors in an experiment that cause dataset distribution shifts. Batch effects usually lead to inaccurate conclusions if the causes are correlated with outcomes of interest and should be accounted for (usually removed). 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 survives logging out or closing the laptop; contrasted 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, blacklists, and region annotations; unlike GTF and VCF, BED uses 0-based, half-open coordinates (start inclusive, end exclusive). Learn more →
Benchmark: An (independent) comparison of the performance of several tools with respect to pre-defined metrics. Learn more →
Benjamini–Hochberg (BH) procedure: The standard method for controlling the false discovery rate when testing many hypotheses simultaneously (e.g., all genes in a DE analysis); it ranks raw p-values, compares each to a threshold that scales with its rank divided by the total number of tests, and the resulting adjusted p-values are reported as padj by DESeq2. 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; used as the underlying compression for BAM, CRAM, fragments.tsv.gz, and any bgzipped VCF or BED file that a tabix index accompanies. Learn more →
BigWIG: A binary, randomly indexed format for per-base or per-interval quantitative genome tracks (read coverage, fold-enrichment, methylation); the indexed equivalent of Wig/BedGraph, consumed by genome browsers (IGV, UCSC) without downloading the full file. 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 the analysis and comprehension of high-throughput genomic data, hosted at bioconductor.org. Packages are installed with BiocManager::install() rather than install.packages(). Key workshop packages from Bioconductor include DESeq2, clusterProfiler, celldex, and SingleR.
Bonferroni correction: The most conservative multiple-testing correction, dividing the significance threshold α by the total number of tests performed so that the family-wise error rate (probability of any false positive) is controlled; typically too stringent for the tens of thousands of genes tested in DE analysis, where Benjamini–Hochberg FDR control is preferred. 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, and are later merged back when ready. Learn more →
Bulk RNA sequencing: In contrast to single-cell sequencing, bulk sequencing measures the average expression values across many cells. Resolution is lost, but bulk sequencing is usually cheaper, less laborious, and faster to analyze. Learn more →

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 →
Canonical correlation analysis (CCA): A dimensionality-reduction method that finds shared sources of variation between two datasets. In Seurat it is one way to identify integration anchors across batches. Learn more →
Cell: The fundamental unit of life, consisting of cytoplasm enclosed within a membrane, containing biomolecules such as proteins and nucleic acids. Cells acquire specific functions, transition into different types, divide, and communicate to sustain an organism. Learn more →
Cell Ranger: 10x Genomics’ pipeline that turns raw sequencing reads (FASTQ) into a cell-by-gene count matrix, performing alignment, barcode/UMI correction, and cell calling. Learn more →
Cell state: Cells can be annotated according to cell type or other states defined by the cell cycle, perturbational state, or other features. Learn more →
Cell type: Cells that share common morphological or phenotypic features. Learn more →
Cell type annotation: The process of labeling groups of clusters of cells by cell type. Commonly done based on cell type-specific markers, automatically with classifiers, or by mapping against a reference. Learn more →
CellChat: An R package for inferring cell–cell communication from scRNA-seq data by testing whether ligand–receptor pairs are co-expressed between cell types, grouping interactions into biologically coherent signaling pathways, and modelling multi-subunit receptor complexes. Learn more →
celldex: A Bioconductor package providing curated reference expression datasets (e.g., HumanPrimaryCellAtlasData, BlueprintEncodeData) used by SingleR for reference-based annotation. Learn more →
CELLxGENE: The Chan Zuckerberg Initiative’s data portal and browser for schema-validated single-cell datasets; every deposited dataset is an AnnData .h5ad object conforming to a required metadata schema (cell ontology, tissue, disease, sex), and the CELLxGENE Census API allows cross-dataset queries across all deposited cells. Learn more →
Checkpoint (pipeline): An intermediate output file — typically an .rds or .h5ad object — written to disk after each stage of a chained pipeline so that a later stage can be re-run from that point without repeating all preceding steps; the workshop’s 01–08 scripts use .rds checkpoints as hand-offs between batch jobs. Learn more →
Chromatin: The complex of DNA and proteins that efficiently packages DNA inside the nucleus and is involved in regulating gene expression. Learn more →
chromatin accessibility: A measure of how physically open (nucleosome-free) a genomic region is, making it accessible to transcription factors and the transcriptional machinery; scATAC-seq quantifies chromatin accessibility genome-wide at single-cell resolution by detecting sites where Tn5 transposase preferentially inserts, indicating open chromatin. 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 single-cell workloads the number of cores is usually the more important spec. Learn more →
Clone: The Git operation (git clone) that downloads a complete copy of a remote repository — including its full commit history, branches, and tags — to a local machine. Learn more →
Cluster: A group of a population or data points that share similarities. In single-cell, clusters usually share a common function or marker gene expression that is used for annotation (see cell type annotation). Learn more →
clusterProfiler: An R/Bioconductor package for functional enrichment analysis — GO/KEGG over-representation and GSEA — used to interpret differentially expressed gene lists. Learn more →
Codon: A sequence of three nucleotides corresponding to a specific amino acid or a start/stop signal in protein synthesis. Codons are the basic units of the genetic code. 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 (CLI). The command line is scriptable, composable, and works identically on a laptop and on a remote HPC cluster — essential for bioinformatics. Learn more →
Commit: A snapshot of a project’s file state recorded by Git, identified by a unique hash, accompanied by an author, timestamp, and descriptive message; the fundamental unit of Git history. Learn more →
Complementary DNA (cDNA): DNA synthesized from an RNA template by the enzyme reverse transcriptase. cDNA is commonly used in RNA-seq library preparation because it is more stable than RNA and allows captured transcripts to be amplified and sequenced. Learn more →
Compute node: A dedicated machine in an HPC cluster on which actual analysis runs; SLURM reserves one exclusively for your job after you declare your resource needs with sbatch or srun, providing CPUs, memory, and optionally GPUs that no other job shares during your allocation — contrasted 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; used in HPC contexts to install Python- or R-based tools that are not available as Lmod environment modules, and by Bioconda to distribute bioinformatics software. Learn more →
Conserved markers: Genes that mark a cluster consistently across conditions. FindConservedMarkers tests each condition separately and combines the p-values, so the marker is not an artifact of a treatment effect. Learn more →
Container: A self-contained, portable package that bundles an operating system, runtime, and all software dependencies into a single image file, ensuring the same execution environment on any host; in HPC contexts, Docker images are typically converted to Apptainer (.sif) format for cluster use. Learn more →
Container image: The immutable, versioned file (.sif for Apptainer, a layer archive for Docker) from which container instances are launched; pulling a specific image tag and committing it to disk is the strongest reproducibility guarantee because the entire software stack is frozen at that version. Learn more →
Core: An independent processing unit within a CPU. A quad-core CPU can genuinely run four tasks simultaneously. R uses a single core by default; parallel operations require explicit setup (e.g., BiocParallel, future). Having more cores matters when you run Cell Ranger or SLURM jobs that use multiple threads. Learn more →
CpG: A DNA sequence in which a cytosine (C) is followed by a guanine (G) along the 5’→3’ direction, linked by a phosphodiester bond. CpG sites are often found in clusters called CpG islands near gene promoters. Unmethylated CpG sites are associated with gene activation, while methylated CpG sites can lead to gene inhibition. 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 Modules 00–08 the CPU is the primary compute resource; the GPU becomes relevant for deep-learning steps. Learn more →
CRAN: The Comprehensive R Archive Network — the official repository for general-purpose R packages, accessed with install.packages(). Contrast with Bioconductor (genomics-specific 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). Preferred for small result tables because it is human-readable and software-agnostic. See also TSV. Learn more →
CytoTRACE: A computational method that scores cells by the breadth of their detected transcriptome (more genes detected ≈ less differentiated) as a proxy for differentiation state; useful for validating trajectory root-cell selection without requiring a kinetics model. Learn more →

D

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). In Seurat, per-cell metadata (seu@meta.data) is a data frame with one row per cell. Learn more →
Demultiplexing: The process of determining which sequencing reads belong to which cell using barcodes. Learn more →
DESeq2: An R/Bioconductor package for differential expression of count data using a negative-binomial model with dispersion shrinkage; the standard tool for bulk and pseudobulk DE. Learn more →
Design matrix: A numeric matrix (rows = samples, columns = model terms) that encodes the experimental factors for a generalized linear model; in DESeq2’s ~ donor + condition formula, the design matrix specifies which sample belongs to which donor group and which condition, and the fitted coefficients give the log2 fold change for each contrast. Learn more →
Diff: In Git, the line-by-line difference between two versions of a file or between two commits; git diff shows unstaged changes, and git diff HEAD~1 shows what changed in the most recent commit. Learn more →
Differential abundance: Testing whether the proportion of a cell type or neighbourhood shifts between conditions (as opposed to expression changes within a cell type). Tools include miloR. Learn more →
Directed graph: A graph consisting of nodes (vertices) connected by edges (arcs), where each edge has a direction indicating a one-way relationship between nodes. 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 →
Dispersion: In a negative-binomial model, the parameter capturing how much a gene’s variance exceeds its mean (overdispersion). DESeq2 estimates per-gene dispersions and shrinks them toward a fitted trend for stable testing. Learn more →
DNA: Deoxyribonucleic acid. The organic chemical storing hereditary information and instructions for protein synthesis. DNA is transcribed into RNA. 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 converted to Apptainer .sif files for use on HPC clusters that do not allow Docker’s daemon (which requires root). Learn more →
Doublets: Reads obtained from droplet-based assays may be mistakenly associated with a single cell when the RNA expression actually originates from two or more cells (a doublet). Learn more →
Downstream analysis: A phase of data analysis that follows the initial processing of raw data. In scRNA-seq, downstream analysis includes normalization, integration, filtering, cell type identification, trajectory inference, and studying expression dynamics. Learn more →
dplyr: An R package (part of the tidyverse) providing a grammar of data manipulation — six core verbs (filter(), select(), mutate(), arrange(), group_by(), summarise()) that cover most data-frame operations in the workshop tutorials. All verbs work naturally with the pipe |>. Learn more →
Driver genes: Genes that actively control or “steer” a cell’s transition from one state to another during a biological process. Unlike marker genes, which merely identify a cell type, driver genes are functionally responsible for the fate decision at a bifurcation point. Learn more →
Drop-seq: A protocol for scRNA-seq that separates cells into nano-liter sized aqueous droplets, enabling large-scale profiling. Learn more →
Dropout: A gene with low expression that is observed in one cell but not in other cells of the same cell type. Dropouts commonly result from low mRNA amounts and the general stochasticity of mRNA expression. Dropouts are one reason scRNA-seq data is sparse. Learn more →
Duck ID: The UO-issued university account identifier (the part of a @uoregon.edu email before the @) used as the login name for SSH access to Talapas, VS Code Remote-SSH connection, and Duo two-factor authentication. Learn more →

E

Edit distance: Also called Levenshtein distance. The minimum number of operations (substitution, insertion, deletion) required to transform one string into another. Learn more →
Elbow plot: A plot of the variance explained (or standard deviation) by each principal component, used to choose how many PCs to keep — the “elbow” marks where additional PCs add little signal. Learn more →
Embedding: A way to represent complex objects (e.g., words, proteins, or genes) as numerical vectors so that computers can analyze them more easily. Learn more →
Enrichment analysis: Methods that ask whether a gene set (e.g., a GO term or pathway) is over-represented among genes of interest. Over-representation tests use a fixed gene list; GSEA uses a ranked list. Learn more →
Environment isolation: The practice of preventing one project’s software versions from affecting another’s, achieved on a laptop with renv or conda, and on a cluster with Lmod modules, renv, or container images; 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, any non-zero value signals an error. Shell scripts check exit statuses to decide whether to continue (&&) or handle failures; SLURM uses the exit status to mark a job as succeeded or failed. Learn more →
ExperimentHub cache: A local Bioconductor disk cache populated by ExperimentHub or AnnotationHub on first data access; on Talapas, compute nodes may lack outbound internet, so running Rscript -e 'invisible(muscData::Kang18_8vs8())' on a login node (which has internet) before submitting jobs populates the cache so batch jobs can read the data without a network request. Learn more →

F

Factor: An R data structure for categorical variables that stores values as a character-like vector together with a fixed, ordered set of allowed values called levels. The first level is the reference in any statistical model — in DESeq2, swapping factor levels flips the sign of every fold-change. 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. Learn more →
Fair-share scheduling: A SLURM priority mechanism that tracks recent CPU usage per 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 →
False discovery rate (FDR): The expected proportion of false positives among the features called significant. p-values are adjusted (e.g., Benjamini–Hochberg) to control the FDR when testing many genes at once. 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 assembled sequences but carrying no quality information (contrast with FASTQ). Learn more →
FASTQ: Sequencing reads saved in the FASTQ format. A FASTQ file stores DNA/RNA sequences and corresponding quality scores in a four-line format: identifier, sequence, optional description, and quality scores encoded in ASCII characters. FASTQ files are mapped against a reference genome to obtain gene counts for cells. 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. Relevant for making shell scripts executable and for protecting raw data directories 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 →
FindMarkers / FindAllMarkers: Seurat functions that identify genes differentially expressed in a cluster relative to the others (default: Wilcoxon rank-sum test). Useful for annotation, but not a replacement for replicate-level DE (see pseudobulk). 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 →
Flowcell: A consumable device used in sequencing platforms on which DNA or RNA fragments are sequenced. It has a glass or polymer surface with lanes or channels coated with oligonucleotides that capture and anchor fragments. During sequencing, fragments are amplified into clusters and their sequences are determined by fluorescent signal detection. 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. Writing small wrapper functions around Seurat or Bioconductor calls is a common pattern throughout the workshop. Learn more →

G

GEM (Gel Bead-in-Emulsion): In droplet platforms (e.g., 10x Genomics), a single droplet containing one barcoded gel bead and ideally one cell, within which all of that cell’s transcripts are tagged with the same cell barcode. Learn more →
Gene expression matrix: A cell (barcode) by gene (scverse ecosystem convention) — or gene by cell (barcode) — matrix storing counts as the cell values. Learn more →
Gene Expression Omnibus (GEO): NCBI’s public repository for processed gene expression data; nearly every published RNA-seq study deposits a count matrix and metadata here under a GSE###### accession, making it the default first stop for retrieving a published dataset. Learn more →
Gene Ontology (GO): A structured, hierarchical vocabulary describing gene products by biological process, molecular function, and cellular component; the basis for GO enrichment analysis. Learn more →
Generalized linear model (GLM): A framework that extends linear regression to non-normal response variables by linking the mean to a linear predictor through a link function; DESeq2 fits a GLM with a negative-binomial distribution and log link to model count data, where the design matrix encodes experimental factors and the estimated coefficients are log fold-changes. Learn more →
Genotype: In a VCF file, the called alleles at a variant site for a specific sample, encoded in the GT field (e.g., 0/1 = heterozygous, 1/1 = homozygous alternate, 0/0 = homozygous reference); the foundation of variant-level population and single-cell genotyping analyses. Learn more →
GFF3 / GTF: Tab-delimited, nine-column annotation formats describing genomic features (genes, transcripts, exons, CDS) on a reference; GTF is the older format required by Cell Ranger and STAR, while GFF3 is the modern fully-specified format used by Ensembl and NCBI — both must match the chromosome naming of the reference FASTA and 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_violin(), etc.) connected with +. The standard for publication-quality figures in this workshop. Learn more →
GitHub: A web-based hosting service for Git repositories that adds collaboration features — pull requests, issues, code review, Actions (CI/CD), 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, *.Rhistory, .DS_Store) Git should never track; essential for keeping large data files, credentials, and temporary outputs out of version control. Learn more →
GPU (Graphics Processing Unit): A processor with thousands of small, simple cores designed for massive data parallelism rather than sequential logic. Relevant for deep-learning-based scRNA-seq tools and for the Talapas Friday modules; most of Modules 00–08 run entirely on the CPU. Learn more →
grep: A Unix command-line tool that searches files or input streams for lines matching a pattern — originally standing for “Global Regular Expression Print.” Supports literal strings and regular expressions; the -v flag inverts the match, -c counts matches, and -n shows line numbers. Ubiquitous in bioinformatics for inspecting FASTA, FASTQ, and annotation files. Learn more →
GSEA (Gene Set Enrichment Analysis): A method that tests whether members of a gene set are concentrated at the top or bottom of a ranked gene list (e.g., ranked by fold change), without imposing a hard significance cutoff. Learn more →
GUI (Graphical User Interface): A point-and-click visual interface to a computer, as opposed to a command line. Most scRNA-seq tools are command-line or script-based rather than GUI-based because GUIs cannot be scripted, version-controlled, or run non-interactively on an HPC cluster. Learn more →

H

H5AD: The on-disk format for AnnData objects (file extension .h5ad), built on HDF5; it stores the expression matrix, per-cell and per-gene metadata, embeddings (obsm), and alternative count layers in a single portable binary file that is readable by both Python (anndata) and R (SeuratDisk, zellkonverter), and is the required submission format for CELLxGENE. Learn more →
Hamming distance: A measure of the number of positions at which two strings of equal length differ. Commonly used in error detection and correction, including barcode correction in sequencing data. Learn more →
Harmony: A fast integration method that corrects batch effects directly in PCA space by iteratively clustering and adjusting cell embeddings, producing a corrected reduction for downstream clustering and UMAP. Learn more →
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 (NAS) 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 sparse storage, and allows random-access reads without loading the entire file; used for 10x’s .h5 count matrix, H5AD, and the Loom format. Learn more →
Highly variable genes (HVG): The subset of genes with the most cell-to-cell variation beyond technical noise. Selecting HVGs (e.g., the top 2,000) focuses dimensionality reduction on the biologically informative features. 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; 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 Research Advanced Computing Services (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 submit jobs that are routed to available compute nodes, while all navigation, editing, and job submission happen on login nodes. Learn more →
Hypergeometric test: The statistical test underlying over-representation analysis (ORA): given a universe of $N$ genes, $K$ of which belong to a gene set, and a significant list of $n$ genes, the hypergeometric distribution gives the probability of observing $k$ or more set members by chance; significant results indicate the set is over-represented in the significant list relative to the background. Learn more →

I

IDE (Integrated Development Environment): A software application that bundles a code editor, terminal, debugger, and version-control interface into one window. RStudio and VS Code are the two IDEs used in this workshop; both provide syntax highlighting, code completion, and an integrated terminal for running R and shell commands. Learn more →
Imputation: The replacement of missing values with (usually artificial) values. Learn more →
Indrop: A droplet-based protocol for scRNA-seq. Learn more →
install.packages() vs library(): The 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 →
Integration: Aligning multiple samples or batches so shared cell types co-cluster while real biological differences are preserved. Methods include Harmony, Seurat CCA/RPCA anchors, and MNN. 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, but the node stays reserved whether or not you are actively typing, so exit immediately when done — contrasted with a batch job. Learn more →

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; the standard pattern for per-sample parallel work (e.g., running Cell Ranger on N samples) without writing N separate scripts; --array=1-N%M caps M simultaneously running sub-jobs to avoid monopolizing the queue. Learn more →
Job ID: The unique integer SLURM assigns to every submitted job (printed as Submitted batch job 123456); used to query job status with squeue -j <id>, cancel with scancel <id>, and retrieve resource usage after completion with seff <id> and sacct -j <id>. Learn more →

K

k-nearest neighbors (kNN): A graph in which each cell is connected to its k most similar cells (typically in PC space). The kNN — and the SNN derived from it — is the substrate for graph-based clustering and UMAP. Learn more →
Kernel: 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 (including R and the shell) interact with the kernel through system calls rather than touching hardware directly. Learn more →

L

Latent semantic indexing (LSI): The dimensionality-reduction step in scATAC-seq analysis that applies singular value decomposition (SVD) to the TF-IDF-normalized peak-by-cell matrix, playing the same role as PCA in scRNA-seq; the first LSI component typically tracks sequencing depth rather than biology and is routinely excluded from downstream clustering and UMAP. Learn more →
Leiden: A graph-based community-detection algorithm (Traag et al. 2019) that improves on Louvain by guaranteeing well-connected clusters. In Seurat it is algorithm = 4 in FindClusters(). Learn more →
LIANA: A consensus framework for cell–cell communication inference that runs multiple tools (CellChat, CellPhoneDB, NicheNet, and others) and ligand–receptor databases in parallel, returning a unified ranked score to reduce sensitivity to any single method’s assumptions. Learn more →
Library: Also known as sequencing library. A pool of DNA fragments with attached sequencing adapters. Learn more →
Likelihood-ratio test (LRT): A statistical test that compares the fit of a full model to a reduced model by computing twice the difference in their log-likelihoods; in DESeq2 it tests whether any level of a multi-level factor contributes significantly to expression, making it suitable for testing a condition with more than two groups where the Wald test tests only a single coefficient. Learn more →
list (R): R’s most flexible data container — each slot can hold any type of object (a vector, a data frame, another list, a function), and slots need not be the same length or type. Seurat and SingleCellExperiment objects are lists under the hood. Access named slots with $name or [["name"]]; access by index 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 readable narrative and executable program. Quarto .qmd files implement literate programming — every workshop tutorial is a .qmd that mixes Markdown text, R code chunks, and their rendered output. Learn more →
Lmod: The hierarchical environment-module system used on Talapas (and most modern HPC clusters) to manage centrally installed software; key commands are 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 to defaults). 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 that renv::restore() can recreate the identical library on any machine; committing the lockfile (but not the library cache) is the standard reproducible computing practice for R projects. Learn more →
Locus: A specific position or region on a genome or transcriptome where a particular sequence or genetic feature is located. In sequencing, loci refer to the potential origins of a read or fragment (e.g., a gene, exon, or intergenic region). Learn more →
Log-normalization: Seurat’s default normalization — divide each cell’s counts by its total, scale by a factor (10,000), and log-transform — making per-cell expression comparable. Learn more →
Log2 fold change (LFC) shrinkage: Moderation of effect-size estimates so that low-information genes (low counts, high variance) are pulled toward zero, giving more reliable rankings (e.g., DESeq2’s apeglm). Learn more →
Login node: The shared gateway machine users land on when they SSH into a cluster (login.talapas.uoregon.edu); intended only for editing files, running short commands, and submitting jobs — never for heavy computation, because all users share it simultaneously; the VS Code Remote-SSH integrated terminal opens a shell on the login node. Learn more →
Loom: An HDF5-based single-cell container format (.loom) developed by the Linnarsson lab, with a matrix slot, col_attrs (per-cell), and row_attrs (per-gene); older than H5AD but still used by RNA-velocity tools (velocyto, scVelo) which write spliced and unspliced count layers to Loom. Learn more →
Louvain: A modularity-optimizing graph-clustering algorithm; Seurat’s default in FindClusters() (algorithm = 1). Fast, but can occasionally produce poorly connected clusters — which Leiden fixes. Learn more →

M

Markdown: A lightweight plain-text formatting language that converts simple syntax (e.g., **bold**, # Heading, `code`) into formatted HTML or PDF. Quarto documents are written in an extended Markdown dialect; the same syntax used for headings, bullet lists, and inline code in this glossary. Learn more →
Marker gene: A gene whose expression is used as an indicator of a particular cell type, biological process, or cellular state. Marker genes are commonly used to identify or classify cells based on their function or identity. Learn more →
Mean–variance relationship: The empirical observation that in RNA-seq count data a gene’s variance increases with its mean but faster than the Poisson expectation (variance = mean), producing a characteristic curve above the Poisson line; modeling this relationship is why DESeq2 and edgeR use a negative-binomial distribution and estimate per-gene dispersion parameters. Learn more →
Merge: The Git operation that integrates changes from one branch into another, creating a merge commit that unifies both histories; the final step in a feature-branch workflow before the branch is deleted. Learn more →
Messenger RNA (mRNA): A nucleotide sequence that has been transcribed from a gene and serves as a blueprint for a protein. Learn more →
Metacell: An aggregate of a few transcriptionally similar cells, summed to reduce sparsity and noise. Used by hdWGCNA and similar methods before co-expression analysis. Learn more →
miloR: An R package for differential-abundance testing on overlapping neighbourhoods of a kNN graph, reporting a per-neighbourhood log-fold change with SpatialFDR control. Learn more →
MNN (mutual nearest neighbors): An integration approach that identifies pairs of cells that are each other’s nearest neighbours across batches and uses them to compute batch-correction vectors. Learn more →
Modalities: Different types of biological information measured at the single-cell level, including gene expression, chromatin accessibility, surface proteins, immune receptor sequences, and spatial organization. Combining modalities provides a more complete understanding of cell identity, function, and interactions. Learn more →
Module eigengene: In WGCNA, the first principal component of a co-expression module’s expression matrix — a single per-sample summary value that is correlated with sample traits. Learn more →
Moran’s I: A spatial autocorrelation statistic that measures whether a continuous variable (e.g., gene expression) is more similar between neighboring spatial spots than would be expected by chance; used by FindSpatiallyVariableFeatures in Seurat to rank genes by the degree to which their expression varies spatially in Visium data. Learn more →
MTX / Matrix Market: A sparse-matrix text format (.mtx) in which only non-zero entries are stored as (row, column, value) triplets; Cell Ranger outputs the count matrix as matrix.mtx.gz alongside barcodes.tsv.gz and features.tsv.gz in the filtered_feature_bc_matrix/ directory, and Read10X() / scanpy.read_10x_mtx() load all three files together. Learn more →
MuData: A Python package for multimodal annotated data matrices that builds on AnnData. The primary data structure in the scverse ecosystem for multimodal data. Learn more →
Muon: A Python package for multi-modal single-cell analysis in Python by scverse. Learn more →

N

Negative binomial distribution: A discrete probability distribution that models the number of successes in a sequence of independent, identically distributed Bernoulli trials before a specified number of failures. Widely used to model overdispersed RNA-seq counts. Learn more →
Nextflow: A workflow manager that represents a pipeline as an explicit dataflow dependency graph, automatically re-running only the stages whose inputs changed, parallelizing independent branches, and integrating with container systems and cloud executors; a natural upgrade from hand-written shell wrappers once a pipeline grows in scale or must process many samples. Learn more →
NicheNet: An R tool for cell–cell communication inference that, instead of testing ligand–receptor co-expression directly, links upstream secreted ligands to the differential gene expression observed in the receiving cell type by propagating signals through a curated prior signaling network; useful for identifying which ligands from a sender cell type can explain the observed transcriptional response in a receiver. Learn more →
Normalization: Adjusting raw counts to remove technical differences in sequencing depth and composition so that expression is comparable across cells (e.g., log-normalization or SCTransform). Learn more →
Normalized Enrichment Score (NES): In GSEA, the raw enrichment score rescaled by the mean of the null distribution derived from permutations, allowing comparison of enrichment scores across gene sets of different sizes; a positive NES indicates enrichment among up-regulated genes, a negative NES among down-regulated genes. Learn more →

O

Open OnDemand: A web portal (ondemand.talapas.uoregon.edu) provided by RACS that gives browser-based access to the Talapas HPC cluster, including a file browser and interactive application sessions (RStudio, JupyterLab, full desktop via VNC) without requiring an SSH client or X server. 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 →
Over-representation analysis (ORA): A functional enrichment method that tests whether genes of interest (e.g., a significant DE gene list) contain more members of a predefined gene set than expected by chance, using a hypergeometric test against a user-specified gene universe; implemented in clusterProfiler::enrichGO() and related functions. Learn more →

P

p-value: The probability of observing a result at least as extreme as the data if the null hypothesis were true; in scRNA-seq DE analysis, raw p-values are never used directly — they are always adjusted for multiple testing (e.g., by Benjamini–Hochberg) to control the false discovery rate. Learn more →
Package: A bundled collection of R functions, data, and documentation that extends base R. Installed once from CRAN (install.packages()) or Bioconductor (BiocManager::install()), then loaded each session with library(). The workshop relies on packages such as Seurat, DESeq2, and the tidyverse. Learn more →
Parallel filesystem: A shared, high-bandwidth storage system (e.g., IBM GPFS/Spectrum Scale on Talapas) visible identically from every login node and compute node in the cluster, so files written on one node are immediately readable on another; enables data-passing between pipeline steps across different compute nodes. Learn more →
Partition: A SLURM concept grouping nodes by hardware class and maximum wall-clock time; every job must target a partition (e.g., compute, computelong, gpu, memory, interactive) that matches its hardware needs and run duration; run sinfo to see current 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. Misconfigured PATH is a common source of “command not found” errors. Learn more →
PCR: Polymerase chain reaction. A method to amplify sequences to create billions of copies. PCR uses primers — short synthetic DNA fragments — to select the genome segments to be amplified and then multiple rounds of DNA synthesis. 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 of dplyr verbs without nested calls or intermediate variables. Every workshop tutorial from Module 01 onward uses |>. 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. Enables powerful one-line workflows by chaining simple, focused tools — e.g., grep "^>" seqs.fasta | sort | uniq | wc -l. Fundamental to the Unix philosophy. Learn more →
Pipeline: Also called a workflow. A pre-specified selection of steps that are commonly executed in order. Learn more →
PIRG (Principal Investigator Research Group): The administrative account unit on Talapas representing a research group; required in every SLURM job submission as --account=<PIRG> for usage tracking and fair-share accounting; PI requests an account for the lab, and members add it to their shell profile (export SLURM_ACCOUNT=<PIRG>) to avoid repeating the flag. Learn more →
Poisson distribution: A discrete probability distribution describing the probability of a specified number of events occurring in a fixed interval of time or space, with events occurring independently at a known constant mean rate. Learn more →
Principal component analysis (PCA): A statistical method used to simplify complex datasets by reducing the number of variables while preserving the main patterns in the data. PCA projects high-dimensional data onto orthogonal axes (principal components) ordered by the amount of variance they explain. Learn more →
Principal graph: In Monocle 3, a graph-topology abstraction of the cell manifold learned by reversed-graph embedding, capable of representing branching differentiation trajectories; the user designates a root node of the graph to define the pseudotime origin, unlike Slingshot, which fits curves through existing clusters. 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 inherited file permissions. Running R in a terminal starts an R process; Cell Ranger starts additional child 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 the research group with a default ~2 TB quota; backed up (unlike scratch space) and appropriate for shared datasets, analysis code, and final outputs that should persist. Learn more →
Promoter: A DNA sequence to which proteins bind (e.g., RNA polymerase and transcription factors) to initiate and control transcription. Learn more →
Pseudobulk: Summing (or averaging) single-cell counts within each (sample/donor × cell type) group to create bulk-like profiles, so that DE can be tested with biological replicates as the unit of analysis — avoiding the pseudoreplication of per-cell tests. Learn more →
Pseudotime: A latent, unobserved dimension reflecting cells’ progression through transitions. Pseudotime is usually related to real-time events but is not necessarily identical. 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 continuous-integration checks before integration into the target branch. Learn more →
Push: The Git operation (git push) that uploads local commits to a remote repository, making them available to collaborators and backing up the work to the cloud. Learn more →

Q

QOS (quality of service): A SLURM limit layer that caps how much one user or group can hold simultaneously (e.g., maximum running jobs, maximum total cores); when a job sits in the queue with reason 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, or slides. Every workshop tutorial and lecture slide deck is a .qmd file; rendering it re-runs all the code, ensuring reproducibility. 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 a matching compute node; monitored with squeue -u $USER, and job priority is determined by fair-share scheduling. Learn more →

R

RACS (Research Advanced Computing Services): The University of Oregon unit that manages the Talapas HPC cluster, handles account provisioning (via racs.uoregon.edu/request-access), provides documentation in the Talapas Knowledge Base, and runs office hours for user support.
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 Seurat object for 50,000 cells can occupy 8–16 GB. “Out of memory” errors (the most common single-cell bottleneck on a laptop) mean the dataset exceeds available RAM. Contrast with disk storage. Learn more →
RCTD (Robust Cell Type Decomposition): A statistical deconvolution method (implemented in the spacexr R package) that estimates cell-type proportions within each spatial spot (Visium) or spatial unit by fitting a mixture model informed by a single-cell reference; outputs fractional weights per cell type per spot, enabling cell-type-resolved spatial analysis. Learn more →
RDS: R Data Serialization — R’s native binary format for saving a single R object (e.g., a Seurat object) to disk with saveRDS() and reloading it with readRDS(). RDS files preserve all object attributes (slots, metadata, assays) exactly and are the standard hand-off format between workshop modules. Learn more →
Reference-based annotation: Labelling cells by comparison to an annotated reference — either by correlation (SingleR) or by anchor mapping/classification (Azimuth) — rather than by manual marker inspection. 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, and R’s grepl() / stringr functions. Indispensable for filtering bioinformatics file headers, finding motifs, and validating data. Learn more →
Relative path: A file path interpreted relative to the current working directory, e.g., ../data/counts.rds (one level up, then into data/). Relative paths are shorter and survive moving the entire project to a new location; 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 the local and remote histories. Learn more →
Remote-SSH (VS Code): A VS Code extension (Microsoft) 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’s filesystem; when connected to Talapas, the green SSH: login.talapas.uoregon.edu banner in the status bar confirms the remote session, and all shell commands run on the login node. Learn more →
Rendering: The process by which Quarto (or R Markdown) executes all code chunks in a .qmd file, weaves the output into the document, and produces the final HTML, PDF, or slide output. Running quarto render or clicking the Render button in VS Code or RStudio triggers rendering. Learn more →
renv: An R package that captures a per-project snapshot of every installed package and its version in an renv.lock file; renv::restore() rebuilds the identical library on any machine (laptop or Talapas), and renv::snapshot() updates the lockfile after adding packages; the workshop ships an renv.lock at the repository root. Learn more →
REPL (Read-Eval-Print Loop): An interactive programming environment that reads one expression at a time, evaluates it, prints the result, and then waits for the next input. The R console in RStudio and the interactive R session in a terminal are both REPLs — they let you experiment with code line by line before committing it 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. Learn more →
Reproducibility: The property of an analysis whereby a second person (or the same person at a later time) 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 contribute to reproducibility. Learn more →
Reproducible computing: The practice of capturing the exact software environment, code, data, and parameters needed to reproduce a result, typically achieved in layers: renv lockfiles pin R package versions, container images pin the OS and system libraries, and environment modules or conda environments isolate tools; on a shared cluster, reproducibility is especially important because the default environment changes as the system is updated. Learn more →
Resolution: The granularity parameter of graph-based clustering. Higher resolution yields more, smaller clusters; lower resolution yields fewer, larger ones. Learn more →
RNA: Ribonucleic acid. A single-stranded nucleic acid present in all living cells that encodes and regulates gene expression. Unlike DNA, RNA can be highly dynamic: a messenger (mRNA) that carries genetic instructions, a structural or catalytic component (rRNA, snRNA), or a regulator of gene expression (miRNA, siRNA, lncRNA). RNA is central to transcription, translation, and cellular responses. Learn more →
RNA velocity: A measure of the rate of change in gene expression, computed by comparing the ratio of unspliced (pre-mRNA) to spliced (mature) mRNA transcripts in single-cell RNA sequencing data. This ratio indicates whether genes are being actively transcribed (increasing expression) or degraded (decreasing expression), allowing researchers to predict the future state of cells. Learn more →
RStudio: An IDE purpose-built for R, providing a Source pane (script editor), Console pane (live R session), Environment/History pane, and Files/Plots/Help pane. The default local environment for R in this workshop. Writing code in the Source pane (rather than the Console) ensures it is saved and reproducible. Learn more →

S

sacct: A SLURM command that queries the accounting database for detailed job statistics after completion (e.g., sacct -j 123456 --format=JobID,ReqMem,MaxRSS,Elapsed,State,ExitCode); useful for extracting MaxRSS (peak memory) and Elapsed (wall time) to right-size future submissions. Learn more →
SAM: Sequence Alignment/Map files. Tab-delimited text files that store sequencing alignment data, showing how reads map to a reference genome. Each line represents a single read alignment with the read sequence, base quality scores, mapping position, and mapping quality. Learn more →
sbatch: The SLURM command to submit a batch job script to the scheduler; returns a job ID on success (Submitted batch job 123456); the script’s #SBATCH directives declare resource needs, and the job runs unattended on a compute node after SLURM grants the allocation. Learn more →
#SBATCH directive: A comment-formatted instruction in a batch script (e.g., #SBATCH --mem=64G) that SLURM reads before executing the script to set resource requirements and job metadata; all directives must appear at the top of the script before any commands, and together they constitute the resource declaration contract with the scheduler. Learn more →
scancel: The SLURM command to cancel a queued or running job by job ID (scancel 123456) or in bulk (scancel -u $USER -t PENDING cancels all your pending jobs). Learn more →
Scanpy: A Python package for single-cell analysis in Python by scverse. Learn more →
Scheduler: Software that translates user resource requests (CPUs, memory, time, GPU) into exclusive reservations on specific compute nodes, ensuring fair sharing of a cluster among many simultaneous users; SLURM is the scheduler on Talapas and most academic HPC systems. Learn more →
scran: A Bioconductor R package providing size-factor normalization specifically designed for sparse single-cell count data (pooling-and-deconvolution approach), as well as HVG selection and downstream QC utilities for SingleCellExperiment objects. Learn more →
Scratch space: The /scratch/<PIRG>/ filesystem on Talapas — large-quota, high-throughput working storage designed for intermediate files and large computation outputs; not backed up and automatically purged after 90 days of inactivity, so it is for transient working data only, never for scripts or final results. Learn more →
Scripting language: A programming language that is interpreted line-by-line at runtime rather than compiled ahead of time, making it fast to write and iterate. Bash, R, and Python are all scripting languages. The shell scripts used to automate bioinformatics pipelines and the R scripts in every workshop module are examples. Learn more →
SCTransform: A normalization method that models counts with a regularized negative-binomial regression, stabilizing variance and selecting HVGs in a single step — an alternative to NormalizeData + ScaleData. Learn more →
Scverse: A consortium for fundamental single-cell tools in the life sciences that maintains computational analysis tools like scanpy, muon, and scvi-tools. See https://scverse.org/.
seff: A SLURM utility (not part of core SLURM but installed on most clusters) that prints a friendly summary of a completed job’s resource usage — CPU efficiency, memory efficiency, peak memory, and wall time — as seff <jobid>; the primary tool for right-sizing future submissions. Learn more →
Sequence Read Archive (SRA): NCBI’s repository for raw sequencing reads (FASTQ / BAM), linked to GEO processed data via BioProject and BioSample accessions; the source for re-aligning a published dataset with a newer reference or pipeline, accessed via sra-tools (prefetch + fasterq-dump) or the EBI mirror (ENA). Learn more →
Sequencing: The process of deciphering the order of DNA nucleotides. Learn more →
Shared nearest neighbor (SNN): A graph derived from the kNN graph in which each edge is weighted by how many neighbours two cells share (Jaccard index). Seurat performs clustering on the SNN graph. Learn more →
Shell: A command interpreter that accepts text commands, passes them to the operating system, and returns output as text. Bash (and zsh 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 run non-interactively, making entire pipelines reproducible. Learn more →
Shell script: A text file of shell commands with a shebang line (e.g., #!/bin/bash) that can be executed as a program. Shell scripts automate repetitive tasks, implement bioinformatics pipelines (e.g., quality-trimming + alignment + quantification), and serve as the job scripts submitted to SLURM on an HPC cluster. Learn more →
Signac: An R package built on the Seurat framework for single-cell chromatin accessibility (scATAC-seq) analysis, providing TSS enrichment scoring, nucleosome signal QC, peak-by-cell ChromatinAssay objects, TF-IDF normalization, LSI dimensionality reduction, and motif enrichment analysis. Learn more →
Signal-to-noise ratio (SNR): A measure of the clarity of a signal relative to background noise. In sequencing, signal is the detectable information derived from the DNA or RNA molecules being sequenced, while noise includes random errors or unwanted signals. A high SNR indicates a strong, reliable signal and better data quality; a low SNR means noise may reduce accuracy. Learn more →
SingleCellExperiment: The Bioconductor R container for single-cell data, storing count matrices in assays, per-cell metadata in colData, per-gene metadata in rowData, and reduced-dimension embeddings in reducedDims; the substrate for the Bioconductor scRNA-seq toolkit (scran, scater, miloR, SingleR). Learn more →
SingleR: A reference-based annotation method that assigns each cell the label of the reference profile it correlates with most strongly (Spearman), with iterative fine-tuning and per-label confidence scores. Learn more →
Size factor: A per-sample (or per-cell) scaling constant that accounts for differences in total library depth; DESeq2’s “median of ratios” estimator computes a robust size factor from all genes so that dividing raw counts by the size factor makes expression comparable across samples without being distorted by highly expressed outlier genes. Learn more →
Slingshot: A trajectory-inference method that fits smooth lineage curves through clusters in a reduced-dimension space and assigns each cell a pseudotime along its lineage. Learn more →
SLURM: The Simple Linux Utility for Resource Management — the scheduler and resource manager 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). Learn more →
Snakemake: A Python-based workflow manager that represents a pipeline as an explicit file-level dependency graph (rules with input: and output: files), automatically re-running only rules whose inputs have changed and parallelizing independent rules; a natural upgrade from shell wrappers for pipelines that must process many samples or restart robustly after partial failures. Learn more →
Soft-thresholding power (β): In WGCNA, the exponent applied to gene–gene correlations to build a weighted network; chosen as the smallest β giving an approximately scale-free topology (R² ≳ 0.8). Learn more →
SoupX: A tool that estimates and removes ambient RNA contamination (“the soup”) from droplet scRNA-seq counts, using the empty-droplet profile as the background estimate. Learn more →
Sparse data: Data that mostly measures zeros and rarely other values (sparse data vs. missing data). Common in gene expression data, where many genes are not expressed in most cells. Learn more →
Sparse matrix: A storage format for sparse data. Instead of keeping all zeros, a sparse matrix saves only the non-zero values and their positions, saving space and making calculations faster. Learn more →
Spatial transcriptomics: Technologies that measure gene expression while preserving the two-dimensional (or three-dimensional) spatial position of cells or spots within a tissue section; the Visium platform tiles 55 µm capture spots across the tissue, while imaging-based methods (MERFISH, CosMx) achieve single-cell or sub-cellular resolution. Learn more →
SpatialFDR: A multiple-testing correction used by miloR that accounts for the overlap between neighbourhoods on the graph — analogous to the FDR but weighted by neighbourhood connectivity. Learn more →
Spike-in RNA: RNA transcripts of known sequence and quantity, used to calibrate measurements in RNA hybridization steps for RNA-seq. Learn more →
Splice junctions: Locations where introns are removed and exons joined together in a mature RNA transcript during RNA splicing. Splice junctions occur at specific nucleotide sequences and are critical for the proper assembly of functional mRNA. Learn more →
squeue: The SLURM command to list queued and running jobs; squeue -u $USER shows your own jobs with state codes (PD pending, R running, CG completing) and a Reason column explaining why pending jobs are not yet running; jobs disappear from squeue once they complete, so use seff or sacct for post-completion accounting. Learn more →
srun: The SLURM command to launch a job step or start an interactive session on a compute node; srun --pty bash is the standard incantation for requesting an interactive shell, with flags such as --account, --partition, --mem, and --time declaring the resource needs. Learn more →
SSD (Solid-State Drive): A storage device that uses NAND flash memory with no moving parts, offering much lower access latency (~0.1 ms) and higher throughput than an HDD. Keeping scRNA-seq input files on an SSD significantly speeds up the initial data-loading step. 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’s file browser and integrated terminal to the cluster. Learn more →
SSH key: A cryptographic key pair (public + private) that authenticates SSH connections without a password; on Talapas, an ED25519 key pair can be generated with ssh-keygen -t ed25519 and the public key added to ~/.ssh/authorized_keys on the cluster to skip password entry (Duo two-factor authentication is still required by policy). Learn more →
SSH tunneling: Forwarding a network port from a remote server through an encrypted SSH connection to the local machine (e.g., ssh -L 8787:localhost:8787 ...), commonly used to access a Jupyter or RStudio server running on a compute node from a local browser without opening a public port on the cluster. Learn more →
Staging area: In Git, the intermediate zone (also called the index) where files are placed by git add before being permanently recorded in a commit; allows selective packaging of changes into logically coherent commits rather than committing all modified files at once. Learn more →
stdin / stdout / stderr: The three standard I/O streams every Unix process inherits: stdin (stream 0) is the default input (keyboard or redirected file); stdout (stream 1) is the default output (terminal or redirected 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 — analogous to a desktop shortcut. On HPC clusters, symbolic links are used to give projects easy access to shared reference genomes stored in a central location 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. VS Code and RStudio provide syntax highlighting for R, Bash, and Quarto documents, making code easier to read and errors easier to spot. Learn more →

T

t-SNE: t-distributed stochastic neighbor embedding — a non-linear method for visualizing high-dimensional data in 2D that emphasizes local structure. Largely superseded by UMAP for scRNA-seq. Learn more →
tabix: A tool (from the htslib suite) that creates a coordinate-sorted index (.tbi) for any bgzipped tab-delimited file with genomic coordinates (VCF, BED, GFF, GTF, fragments.tsv.gz), enabling rapid random-access queries by genomic region without scanning the entire file. Learn more →
Tag: In Git, a named, immutable reference to a specific commit, most commonly used to mark release points (e.g., v1.0); unlike branches, tags do not move as new commits are added, making them suitable for citing a specific version in a publication or archival deposit. Learn more →
Talapas: The University of Oregon’s flagship HPC cluster, named from the Chinook word for coyote; managed by RACS, it provides over 14,500 CPU cores, ~89 GPUs, and ~3 PB of storage, and is accessed via SSH or Open OnDemand using a Duck ID and Duo two-factor authentication. Learn more →
Terminal: An application that provides a text window in which you interact with a shell. On macOS the built-in app is called Terminal; on Windows with WSL it is the WSL/Ubuntu terminal; VS Code has a built-in integrated terminal (Ctrl/Cmd+`). “Terminal” and “command line” are often used interchangeably in casual usage. Learn more →
Text editor: A program for creating and editing plain-text files — without the formatting imposed by word processors. Simple editors (nano, vim) work in a terminal; feature-rich editors (VS Code, RStudio) add syntax highlighting, autocompletion, and Git integration. All R scripts, shell scripts, and .qmd files are plain-text files editable in any text editor. Learn more →
TF-IDF (term-frequency–inverse-document-frequency): A normalization strategy borrowed from text mining and adapted for scATAC-seq: each peak’s accessibility in a cell (term frequency) is weighted by how rarely that peak is accessible across all cells (inverse document frequency), up-weighting cell-type-specific peaks and down-weighting ubiquitously open promoters before LSI dimensionality reduction. Learn more →
tibble: An enhanced data frame from the tibble package (part of the tidyverse) that prints more concisely (showing only as many rows as fit the console), never converts strings to factors by default, and gives cleaner error messages when columns are mistyped. 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 — designed around a consistent, pipe-friendly grammar for data import, tidying, transformation, and visualization. Loaded with library(tidyverse); used in every workshop tutorial from Module 01 onward. Learn more →
Topological overlap matrix (TOM): In WGCNA, a similarity measure between genes that also accounts for shared network neighbours; clustering on 1 − TOM groups genes into co-expression modules. Learn more →
Trajectory inference: Also known as pseudotemporal ordering. The computational recovery of dynamic processes by ordering cells by similarity or other measures. Learn more →
TSV: Tab-Separated Values — a plain-text file format like CSV but using tab characters as delimiters. Common for gene count tables and annotation files in bioinformatics because gene names themselves may contain commas. Read with read_tsv() in the tidyverse. Learn more →

U

UMAP: Uniform Manifold Approximation and Projection — a non-linear dimensionality-reduction method for 2D visualization that preserves local (and some global) structure; the standard scRNA-seq embedding plot. Learn more →
Unique Molecular Identifier (UMI): A special type of molecular barcode that uniquely tags each molecule in a sample library. UMIs enable the estimation of PCR duplication rates (see amplification bias), which supports error correction and increases accuracy. Learn more →
Untranslated Region (UTR): A segment of an mRNA transcript that is transcribed but not translated into protein. UTRs are located at both ends of the coding sequence. Learn more →

V

Variance-stabilizing transformation (VST): A transformation (e.g., DESeq2::vst) that makes a count variable’s variance roughly independent of its mean, useful before PCA, clustering, or WGCNA on bulk/pseudobulk data. Learn more →
VCF (Variant Call Format): A tab-delimited format for recording genomic variant calls (SNVs, indels, structural variants) at specific positions relative to a reference, with a metadata header section, mandatory columns (CHROM, POS, REF, ALT, QUAL, FILTER, INFO), and per-sample genotype columns; BCF is the binary, indexed equivalent used for large cohorts. Learn more →
Vector: R’s fundamental data structure — an ordered sequence of values all of the same type (numeric, character, logical, or factor). Nearly all R operations are vectorized: arithmetic and comparisons apply element-wise to every value at once without an explicit loop, making code concise and fast for the thousands-of-genes or thousands-of-cells operations typical in single-cell analysis. Learn more →
Vectorization: The property of R (and many scientific languages) whereby operations automatically apply element-wise to every element of a vector or column of a data frame, with no explicit loop required. For example, counts > 4 tests every element of counts in one expression. Vectorization is why R handles thousands of cells or genes efficiently in a single expression. Learn more →
Version control: The practice of systematically tracking changes to files over time so that earlier states can be recovered, alternative versions can be developed in parallel branches, and contributions from multiple collaborators can be merged; Git is the dominant version-control system in computational biology. Learn more →
Virtual machine (VM): A software emulation of an entire computer — hardware, operating system, and installed programs — that runs inside another host computer. VMs are used to run Linux on a Windows laptop or to create reproducible computing environments; containers (e.g., Docker) are a lighter-weight alternative increasingly used for portable bioinformatics pipelines. Learn more →
Visium: 10x Genomics’ array-based spatial transcriptomics platform that captures whole-transcriptome gene expression at ~55 µm capture spots arrayed across a tissue section, with expression linked to the H&E histology image; spot-level data are processed by spaceranger and analyzed in Seurat with Load10X_Spatial(). Learn more →
VS Code (Visual Studio Code): A free, open-source, cross-platform IDE from Microsoft that supports R, Python, Bash, and Quarto through extensions, and includes syntax highlighting, autocompletion, Git integration, and an integrated terminal. Used throughout this workshop for editing .qmd files and for connecting to Talapas via Remote-SSH. Learn more →

W

Wald test: DESeq2’s default hypothesis test for a single model coefficient: the estimated log fold-change is divided by its standard error to form a z-statistic, and the p-value is derived from the normal distribution; faster and appropriate for simple two-group contrasts, but replaced by the likelihood-ratio test when testing multi-level factors. Learn more →
Wall-clock time vs CPU time: Wall-clock time (elapsed real time) is what --time limits and seff reports as “Job Wall-clock time”; CPU time is wall-clock × cores and measures total processor work; a 1-hour job on 8 cores consumes 8 CPU-hours but 1 hour of walltime — understanding the difference is important for both right-sizing time limits and interpreting CPU-efficiency figures from seff. Learn more →
Walltime / time limit: The maximum elapsed (wall-clock) time a SLURM job is allowed to run, set with --time=HH:MM:SS; when the job exceeds this limit, SLURM terminates it immediately with state TIMEOUT — there is no grace period; contrast with CPU time, which is cores × elapsed time and can exceed walltime when multiple cores are used. Learn more →
WGCNA: Weighted Gene Co-expression Network Analysis — builds a weighted co-expression network, detects modules of co-regulated genes, summarizes each module as an eigengene, and correlates modules with sample traits. Learn more →
wget / curl: Command-line tools for downloading files from URLs. wget URL saves the file to the current directory; curl -o filename URL saves to a named file. Both are used to pull reference genomes, annotation files, and datasets directly to a server or cluster without a browser. Learn more →
Wilcoxon rank-sum test: A non-parametric test that compares two groups by rank; Seurat’s default marker test in FindMarkers / FindAllMarkers. Learn more →
Wildcard / globbing: Patterns that the shell expands into matching filenames before passing them to a command. Common wildcards: * matches any string, ? matches one character, [abc] matches a character in the set. For example, ls *.fastq lists all FASTQ files. “Globbing” refers to this shell expansion process. Learn more →
Workflow manager: A tool (Snakemake, Nextflow) that represents a computational pipeline as an explicit dependency graph of inputs and outputs, tracking which steps are complete, automatically skipping finished stages, and rerunning only affected steps when inputs change; a more robust and scalable alternative to hand-written shell wrappers for production or multi-sample pipelines. Learn more →
Working directory: The directory a process is currently “standing in,” used as the base for interpreting relative paths. In the shell, pwd prints it and cd changes it. In R, getwd() and setwd() read and set it. Every R session and shell session has exactly one working directory at any moment. Learn more →

Y

YAML header: The block of configuration metadata at the top of a Quarto .qmd file, delimited by --- lines, written in YAML (Yet Another Markup Language). It sets document title, author, output format, and chunk-execution options (eval: false, echo: true, etc.). Every workshop .qmd file begins with a YAML header. Learn more →

Definitions adapted, with modifications, from the Single-cell best practices glossary (Heumos et al.), licensed under the terms of that project.