Key computing terms#
Use this page when an unfamiliar computing term appears in MQB. Each chapter explains a term again when it is needed for an activity; this page is a short place to look it up.
Terminal and shell#
Terminal#
A terminal is an application window where you type commands and see their output. On macOS it is usually called Terminal; on Linux it may be Terminal, GNOME Terminal or a similar name. VS Code and other modern code editors also have an integrated terminal.
Shell#
A shell is the program inside a terminal that reads the commands you type and starts other programs. MQB mainly uses Bash. A terminal is the window; the shell is the command-reading program in that window.
Paths, files and systems#
Paths and the current directory#
A path names the location of a file or folder. The current directory is the folder a terminal or program is using right now. The pwd command prints that folder.
An absolute path gives the complete location, starting at the top of the file system. For example, /opt/homebrew/bin/brew is an absolute path on many Apple Silicon Macs. A relative path starts from the current directory, such as data/observations.csv.
Project root#
A project root is the main folder for one project, whether coursework or independent study. In MQB examples it normally contains README.md, code, data and results. The outer folder’s name is not part of the example’s internal paths: bootcamp students can keep using MQB_Bootcamp, while independent learners choose their own name. Shell, Python and R scripts can share the same project. See Organising your learning project.
Unless an exercise names another starting directory, return to this root before running a script. A path such as data/observations.csv is then relative to the root, so the whole project can move without embedding one person’s absolute path. Exercises about navigation, notebooks and HPC jobs may state a different starting directory explicitly.
PATH#
PATH is a list of folders that a shell searches when you type a command name. If the folder containing a program is on PATH, you can type the program’s short name, such as brew, instead of its full path. command -v NAME shows the location the shell would use for a command named NAME.
Startup file#
A startup file is a settings file that a shell reads when a new terminal session starts. A line added there affects future sessions. To apply the change to the current terminal, source the file explicitly or close and reopen the terminal. Your shell and the kind of terminal session determine which startup file it reads; follow the setup instructions for your own system and change only the line you added.
Package manager and package#
A package manager installs, updates and removes software in a controlled way. Homebrew on macOS and APT on Ubuntu are package managers. A package is one unit of software managed this way; it may provide a command, a library or an application.
Python and notebooks#
Python environment and interpreter#
A Python interpreter is the program that runs Python code. A Python environment is a project-specific place where that interpreter uses its own installed packages. A venv is the standard Python tool for creating such an environment. Activating it tells the current terminal to use that project’s Python first.
Notebook kernel#
A notebook kernel is the running program that executes notebook cells and keeps variables in memory. A Python interpreter selected for a script and a kernel selected for a notebook can be different, so check both when working in an editor. A kernel also has a current directory; selecting it does not guarantee that relative paths start at the project root.
Git and GitHub#
Repository and remote#
A Git repository is a project folder together with its saved history of changes. A remote is a named local connection to another repository, usually represented by a URL. origin is a conventional name for that connection; it is a label chosen in your local repository, not the name of a special GitHub server.
Command, option and argument#
A command is an instruction given to a shell, such as pwd or git status. An option or flag changes how a command behaves, often beginning with - or --. An argument is an input supplied to a command, such as a filename or directory.
Standard input, output and error#
Standard input is data read by a program, normally from the keyboard or another command. Standard output is normal program output, and standard error is diagnostic output. They are commonly abbreviated as stdin, stdout and stderr.
Pipe and redirection#
A pipe, written |, sends the output of one command to the input of another. Redirection sends input or output to a file, using operators such as <, > and >>.
Exit status#
An exit status is the numeric result a command returns to the shell. Zero normally means success; a non-zero value normally indicates an error or another condition.
Operating system#
An operating system manages a computer’s hardware and provides services for programs. Linux, macOS and Windows are operating systems.
CPU and processor#
The central processing unit (CPU), or processor, executes program instructions. A CPU may contain multiple cores that can run independent tasks concurrently.
RAM and memory#
RAM is fast temporary working space used by running programs. Its contents are normally lost when the computer shuts down. RAM is different from persistent storage such as an SSD.
Storage#
Storage is persistent space for files and programs, such as an SSD, hard drive or network drive. Storage retains data when the computer is turned off.
File system#
A file system is the structure and set of rules an operating system uses to organise files and folders on storage.
Architecture#
Computer architecture is the design and instruction set targeted by software, such as x86_64 or ARM64. Programs and packages must be compatible with the system architecture.
Process#
A process is a running instance of a program, with its own memory and system resources.
Permissions and executable files#
File permissions control who can read, modify or run a file. An executable is a program or script that the operating system is allowed to run.
Environment variable#
An environment variable is a named value made available to programs started by a shell. PATH is one example. Commands such as export NAME=value set variables for the current shell and its child processes.
Editors and development tools#
Code editor#
A code editor is a program for writing and editing source code. Examples include VS Code, Vim and Emacs.
Integrated development environment (IDE)#
An integrated development environment (IDE) combines tools for writing, running, debugging and testing code. Examples include VS Code, RStudio, PyCharm and Visual Studio. An IDE can still use a separately selected interpreter or environment.
Integrated terminal#
An integrated terminal is a terminal panel inside an editor such as VS Code. It still runs a shell separately from the editor itself.
REPL#
A REPL is a read-evaluate-print loop: an interactive prompt that reads code, evaluates it and displays the result. The Python prompt and R console are examples.
Debugger#
A debugger is a tool for pausing a program, stepping through execution, inspecting variables and locating errors.
Linter and formatter#
A linter detects possible errors or style problems. A formatter automatically rewrites code into a consistent layout.
Extension or plugin#
An extension or plugin is an add-on that provides language support, debugging, notebook integration or other editor features.
Language server#
A language server is a background service that provides features such as syntax checking, completion, documentation, navigation and refactoring.
Script, module and package#
A script is a file intended to be run as a program. A module is a file or collection of code that can be imported and reused. A package is a collection of related modules distributed as a unit.
Dependency#
A dependency is software that a program or project relies on, such as a Python package or an external command. Dependencies should be recorded so another person can reproduce the environment.
pip#
pip is a tool for installing and managing Python packages. Use the interpreter-bound form, such as python -m pip, when several Python installations may exist.
Notebook#
A notebook is a document that combines explanatory text, executable code, visualisations and saved output. Jupyter Notebook, JupyterLab and VS Code provide notebook interfaces.
Code cell and Markdown cell#
A code cell contains executable code. A Markdown cell contains formatted explanatory text, links, equations or other documentation.
Restart#
To restart a notebook kernel is to stop and start it again. Restarting clears variables, imports and other state held in memory.
Working tree#
The working tree is the set of files currently checked out on disk. It can contain changes that have not yet been staged or committed.
Staging area and index#
The staging area, also called the index, is the proposed content for the next commit. git add places changes there; git diff --cached shows what is staged.
Commit#
A commit is a saved snapshot of selected project changes with a message, author and position in the repository history.
Branch#
A branch is a movable name pointing to a line of commits. Branches allow work to be developed and reviewed separately from another branch such as main.
HEAD#
HEAD identifies the commit, branch or other revision currently checked out. git status reports the current HEAD and branch.
Clone, fetch, pull and push#
To clone is to create a local repository from a remote. To fetch is to download remote commits without changing the current files. To pull usually means fetch followed by an integration step. To push is to send local commits to a remote.
Merge conflict#
A merge conflict occurs when Git cannot combine changes automatically, often because two changes affect the same lines. A person must choose the intended result, then stage and commit the resolution.
.gitignore#
.gitignore lists files and folders that Git should normally leave untracked, such as build output, caches, local environments and secrets. It does not stop tracking a file that was already committed.
Fork and pull request#
A fork is a separate GitHub copy of a repository under another account or organisation. A pull request proposes changes from one branch or repository to another for review and possible merging.
Testing and checking results#
Test case and expected result
A test case is one specified input or situation together with the behaviour you expect. Work out or justify the expected result independently before comparing it with the program’s observed result. A collection of test cases is a test suite.
Assertion
An assertion is an executable statement that checks whether a condition is true. In Python, assert result == expected passes silently when the condition is true and raises AssertionError when it is false. Assertions help express tests, but the person writing the test must still justify the expected result.
Unit test
A unit test checks one small unit of code, usually a function, separately from the larger program. Small, focused tests make it easier to identify which behaviour broke after a change.
Normal-case testing
A normal case uses typical valid input and checks the main intended behaviour. It is a useful starting point, but normal cases alone often miss errors at thresholds, empty inputs, missing data or other edges.
Boundary testing or Boundary Value Analysis (BVA)
Boundary testing, also called Boundary Value Analysis (BVA), checks behaviour at the edges of a rule and, where meaningful, immediately on either side. If a threshold is 10, cases such as 9, 10 and 11 can reveal whether the code uses > or >= correctly. Boundaries are defined by the problem and the function’s contract: they can include empty input, an all-missing group, capacity limits, dates or the first and last permitted values—not only numeric minima and maxima.
Failure-case or negative testing
A failure case supplies invalid or unsupported input and checks that the program rejects it or reports the expected error clearly. This is sometimes called negative testing. It does not mean deliberately breaking unrelated parts of the system; it means verifying the promised response to bad input.
Data and configuration#
CSV, JSON and YAML#
CSV stores tabular data as rows and delimiters. JSON stores structured data using objects, arrays and values. YAML stores structured, human-readable configuration and data. Each format has different rules for quoting, nesting and data types.
Metadata#
Metadata is information that describes other data, such as units, column meanings, provenance, collection methods or software versions.
Reproducibility#
Reproducibility means that another person can repeat an analysis and obtain the same or appropriately equivalent results using the recorded code, data, environment and instructions.
SSH keys#
SSH uses a pair of related files to prove that you control an account. The private key stays on your computer and must remain secret. The public key can be added to GitHub. A passphrase protects a private key if the file is copied; it is not your GitHub password.