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 toapptainer pullan image from Docker Hub, and thenapptainer 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
sbatchthat 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 thaninstall.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, andcp 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
mainbranch; 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
.rdsor.csvfile) 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
sbatchorsrun. 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 (
.sifformat). Learn more → - Container image
-
The immutable, versioned file (
.siffor 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
futureorparallelpackages, Pythonmultiprocessing). 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) orread.csv()(base R), and into Python withpandas.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 cudaalongside 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
pandaslibrary provides an equivalentDataFrame. Learn more → - Diff
-
The line-by-line difference between two versions of a file. In Git,
git diffshows unstaged changes andgit diff HEAD~1shows what changed in the most recent commit; the standalone Unixdiff file1 file2compares 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(), andsummarise()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.eduemail 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 withecho $VARorenv. Learn more → - Exit status
-
The integer code a process returns when it finishes:
0conventionally 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 withecho $?); 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 withgrep -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 byls -l; changed withchmod(e.g.,chmod +x script.shmakes 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 asC:\. 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, withdef name(args):andreturn. Learn more → - future / furrr
-
The R package ecosystem for parallel computing used in this course:
futuresets the plan (how work is distributed), andfurrrprovides parallel drop-in versions of purrr’smap()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
/docsfolder. Quarto renders.qmdfiles to HTML, which GitHub Pages publishes as a website athttps://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
scpwould 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;
-vinverts the match,-ccounts matching lines,-iignores case, and-nshows 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.,
.h5and AnnData.h5adfiles). Learn more → - Here document
-
A shell construct that feeds several lines of text to a command’s stdin directly from the script, between
<<EOFand a closingEOFline. 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 fromlsand wildcards by default;ls -ashows 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/usernameon Linux or/Users/usernameon macOS. Abbreviated~in shell paths. Your shell starts here by default, and configuration files such as.bashrclive 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; useBiocManager::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 bashorsalloc, 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, soexitas 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%Mcaps 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 withsqueue -j <id>, cancel withscancel <id>, and review resource usage after completion withseff <id>andsacct -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 withjsonliteand in Python with the built-injsonmodule. 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.ipynbfiles and can use Jupyter to execute Python code. Learn more →
J.11 K
- 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 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()). Thelibrary()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
$nameor[["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
.qmdfiles 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), andmodule purge(reset). Learn more → - Lockfile
-
A file (e.g.,
renv.lockfor 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 withlibrary(); Python packages are installed withpipor conda and loaded withimport. 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.qmdfiles 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; runsinfoto 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 inPATHuntil it finds an executable namedR. A misconfiguredPATHis a common source of “command not found” errors; inspect it withecho $PATH. Learn more → - Pipe (R
|>) -
The native R pipe operator (introduced in R 4.1; the older
magrittrpipe%>%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 asdf |> 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
Rin a terminal starts an R process;psandtoplist 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 togit fetchfollowed bygit 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
.qmdfiles, 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
sbatchand leave when SLURM finds matching resources; monitor your jobs withsqueue -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 withreadRDS(). 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’sgrepl()andstringrfunctions, and Python’sremodule. 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 intodata/). 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).
originis the conventional name for the primary remote, andgit push/git pullsynchronize 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.eduand shell commands run on the login node. Learn more → - Rendering
-
The process by which Quarto executes all code chunks in a
.qmdfile, weaves the output into the document, and produces the final HTML, PDF, or slides. Triggered withquarto renderor 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.lockfile.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 aspy$x(in R) andr.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#SBATCHdirectives declare resource needs, and the job runs unattended on a compute node. Learn more → #SBATCHdirective-
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 $USERcancels 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.shfile 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),sacctandseff(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:andoutput: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
Matrixpackage, Pythonscipy.sparse). Learn more → squeue-
The SLURM command to list queued and running jobs.
squeue -u $USERshows your jobs with state codes (PDpending,Rrunning,CGcompleting) and a Reason column explaining why pending jobs have not started. Finished jobs disappear fromsqueue; usesefforsacctafterward. 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--timeflags) 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.eduopens 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 addbefore 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 with2>). 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
htslibsuite 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.qmdfiles are all plain text. Learn more → - tibble
-
An enhanced data frame from the
tibblepackage (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, andtibble) built around a consistent, pipe-friendly grammar for data import, tidying, transformation, and visualization. Loaded withlibrary(tidyverse). Learn more → - TinyTeX
-
A lightweight, easy-to-maintain LaTeX distribution designed for R Markdown and Quarto users. Install it with
quarto install tinytexso 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 orpandas.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 > 4tests every element offorce_Nin 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 .venvcreates one andsource .venv/bin/activateturns it on; conda anduvare 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
--timelimits and whatseffreports 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(orD-HH:MM:SS). When the limit is reached SLURM terminates the job with stateTIMEOUT, so leave a reasonable margin. Learn more → - wget / curl
-
Command-line tools for downloading files from URLs.
wget URLsaves the file to the current directory;curl -L -o filename URLsaves 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 *.csvlists 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,
pwdprints it andcdchanges it; in R,getwd()andsetwd(); 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 --installin 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
.qmdfile, 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.