Glossary (combined)

The terms you meet during the pre-work and the workshop, in alphabetical order. Each entry has two layers. The main text defines the term in plain, everyday words, so you can read it once and understand it. The gray block underneath gives the more technical wording for the same term from Glosario, the multilingual glossary maintained by The Carpentries. The technical wording is the vocabulary you will meet in documentation and in other courses, and the link leads to the Glosario entry with translations into other languages. Terms that only exist in this course, such as the RStudio Git pane, have the plain definition only. If you are unsure which tool a term belongs to, see Which tool does what?

branch: A branch is a separate line of work inside a repository. You create a branch when you want to change files without touching the main copy of the project. When the changes have been reviewed, you bring them back into the main copy. In the workshop you make your edits on a branch and bring them into main through a pull request.

Glosario: A snapshot of a version of a Git repository. Multiple branches can capture multiple versions of the same repository.
bug report: A description of an unexpected error or wrong output from a program, written down so that someone can find and fix the problem. On GitHub, bug reports are usually filed as issues.
clone: To clone a repository means to download a full copy of it from GitHub onto your own computer, including the record of every change ever made to it. In RStudio you clone by creating a new project and choosing Version Control, then Git.

Glosario: A copy (usually downloaded) of a Git remote repository on a local computer.
cloud: Computers, storage, and services that you reach over the internet instead of running on your own machine. When we say GitHub stores your repository in the cloud, we mean it stores the repository on GitHub’s servers.
commit: A commit is a saved version of your project. When you commit, Git records the exact content of your files at that moment, together with a message that says what you changed and why. You can go back to any earlier commit at any time.

Glosario: As a verb, the act of saving a set of changes to a version control repository. As a noun, the changes saved.
commit message: A commit message is the short note you attach to a commit. It tells your collaborators, and your future self, what you changed and why you changed it.

Glosario: A comment attached to a commit that explains what was done and why.
credential: A piece of information that proves to a computer system who you are, such as a password or a personal access token. Git keeps your GitHub credential on your computer, so you do not have to retype it for every push and pull.
default branch (main): The default branch is the main copy of the project inside a repository, and it is usually called main. It should always hold a version of the project that works. You make changes on other branches and bring them into main after someone has reviewed them. In older projects the default branch is called master.

Glosario: A dedicated, permanent, central branch which should contain a ready product. After a new feature is developed on a separate branch, it can be merged into this branch.
fork: A fork is a personal copy of someone else’s repository, stored in your own GitHub account. You can change your fork freely, and you can offer your changes back to the original repository through a pull request. We do not use forks in the workshop, because our teams share one repository and work on branches inside it.

Glosario: A copy of one person’s Git repository that lives in another person’s GitHub account. Changes to the content of a fork can be submitted to the upstream repository via a pull request.
Git: Git is a program on your computer that keeps track of changes to your files. It saves the versions you tell it to save, shows you what changed between versions, and lets you go back to any earlier version. Git works without an internet connection.

Glosario: A version control tool to record and manage changes to a project.
GitHub: GitHub is a website that stores a copy of your Git repository online, so that other people can see your project, download it, and work on it with you. GitHub also adds tools that Git itself does not have, such as pull requests and issues.

Glosario: A cloud-based platform built around Git that allows you to save versions of your project online and collaborate with other Git users.
history: The history is the ordered record of all commits made in a repository, from the very first commit to the newest. It shows who changed what, when, and why. Every clone contains the full history, which is why you can recover any earlier state of the project.
HTML: The format used for web pages. Rendering a Quarto document usually produces an HTML page that you can open in any web browser.

Glosario: The standard markup language used for web pages.
HTTPS: The secure way computers exchange data on the web, the same one behind every https:// address. Git talks to GitHub over HTTPS, which is why GitHub asks for a personal access token to prove who you are.
issue: An issue is a to-do item for a project, posted on the repository’s page on GitHub. An issue can describe a problem, ask for something new, or hold a task. You can assign an issue to a person, and you can refer to it from commits and pull requests.

Glosario: A bug report, feature request, or other to-do item associated with a project.
local repository: The local repository is the copy of a repository on your own computer, including the record of every change. Your commits are saved here first. Pushing then uploads them to the copy on GitHub.
Markdown: Markdown is a simple way to add formatting, such as headings, links, and lists, to ordinary text. You type plain characters, e.g. # in front of a heading, and the text is later shown with the formatting applied. GitHub uses Markdown in README files, issues, and pull requests, and Quarto uses it for the text in .qmd documents.

Glosario: A markup language with a simple syntax. Markdown is often used for README files.
markup language: A set of rules for marking up text to say what it means or how it should be shown. The marks themselves are usually not displayed. Markdown and HTML are markup languages.

Glosario: A set of rules for annotating text to define its meaning or how it should be displayed.
merge: To merge means to combine the changes from one branch into another, so that one branch now contains the work of both. In the workshop, the merge happens when a reviewer accepts a pull request on GitHub.

Glosario: Merging branches in Git incorporates the development histories of two branches in one. If changes are made to similar parts of both branches, a conflict will occur.
merge conflict: A merge conflict happens when two branches have changed the same lines of the same file, and Git cannot tell which version you want to keep. Git stops, marks both versions inside the file, and waits for you to choose or combine them. A conflict is not an error. It only means that Git will not guess which change you meant.

Glosario: A situation in which incompatible or overlapping changes have been made on different branches that are now being merged.
metadata: Information that describes other information. The author, date, and message attached to each commit are metadata about the changes in that commit.
open source: Software whose source code is public and licensed so that anyone may use, change, and share it. Git and Quarto are open source. GitHub is not, although it hosts millions of open-source projects.
origin: Origin is the name your computer uses for the copy of your repository on GitHub. Git sets the name automatically when you clone, so that you can push and pull without typing the full web address every time.

Glosario: A short name for a remote repository.
personal access token (PAT): A personal access token is a long password that GitHub generates for you. Git sends it to GitHub when you push or pull, to prove that the request really comes from you. You created a token in pre-work step 4, and you save it on your computer by running gitcreds::gitcreds_set() in the RStudio console.
plain text: Text stored as ordinary characters only, with no hidden formatting, so that any editor on any computer can open it. Git works best with plain text, because it can show exactly which lines changed between versions. Quarto documents, R scripts, and CSV files are all plain text.
pull: To pull means to download the newest commits from GitHub into the copy on your own computer, so that both copies are the same again. Pulling is the first step of the commit cycle. Pull, then stage, then commit, then push.

Glosario: Downloads and synchronizes changes between a remote repository and a local repository.
pull request: A pull request is a page on GitHub where you ask another person to review the changes on your branch and, if the changes are good, to merge the branch into main. The reviewer can read every changed line, write comments, and suggest edits. A pull request is not the same as a pull. A pull downloads commits to your computer, and a pull request is a conversation about merging.

Glosario: The request to merge a new feature or correction created on a branch or fork of a Git repository into the upstream repository. The developer is notified of the change, reviews it, makes or suggests changes, and potentially merges it.
push: To push means to upload your commits from your own computer to the copy of your repository on GitHub. Until you push, your commits exist only on your computer, and nobody else can see them.

Glosario: Uploads and synchronizes changes between a local repository and a remote repository.
Quarto: Quarto is a program that turns a text file into a finished document, such as a report, a website, or slides. A Quarto file ends in .qmd and contains ordinary text, code, and a few settings at the top. When you click Render, Quarto runs the code and builds the document. Quarto does not track versions and does not talk to GitHub.
README: A README is a text file that explains what a project is and how to use it. GitHub shows the file named README.md on the front page of the repository.

Glosario: A plain text file containing important information about a project or software package.
remote repository: The remote repository is the copy of a repository that is not on your computer. For us, the remote repository is the copy on GitHub. Pull and push move commits between your local copy and the remote copy, so that everyone can share their work.

Glosario: A repository located on another computer. Tools such as Git are designed to synchronize changes between local and remote repositories in order to share work.
render: To render means to have Quarto build the output document, e.g. a web page or a PDF, from a .qmd file. Rendering also runs the code inside the file. In RStudio you render by clicking the Render button.
repository: A repository is the folder for one project, together with the full record of every change made to the files in it. Git keeps the record in a hidden part of the folder. As a rule, one project gets one repository.

Glosario: A place where a version control system stores the files that make up a project and the metadata that describes their history.
RStudio Git pane: The RStudio Git pane is the tab in RStudio that shows what has changed in your repository and holds the buttons for everyday Git work. It has the Pull button, the checkboxes for staging, the Commit button, the Push button, and the tools for branches. Every button runs a real Git command. Clicking Push runs git push.
server: A computer, or a program running on it, that provides data or services to other computers over a network. The remote copies of your repositories live on GitHub’s servers.

Glosario: Typically, a program such as a database manager or web server that provides data to a client upon request.
snapshot: The complete state of all files in your project at one moment in time, saved so that you can return to it later. Every commit stores a snapshot, and the history is the ordered line of those snapshots.
stage / staging area: To stage a file means to mark it for the next commit, and the staging area is where Git keeps the marked files until you commit. Git only commits the files you have staged, so you can change five files and commit only two of them. In the RStudio Git pane you stage a file by ticking its checkbox, which runs the command git add.
synchronize: To bring two copies of the same thing to the same state, so that neither is missing changes the other has. Pull and push are how you synchronize your local repository with the remote repository on GitHub.
version control: Version control is a way of working where a program records every saved version of your files, so that you can see what changed, when, and why, and go back to any earlier version. Git is the version control program we use.

Glosario: A system for managing changes made to software during its development.
YAML: YAML is a simple format for settings, written as names and values. The block between the two --- lines at the top of a Quarto file is written in YAML, and it holds settings such as the title and the output format.

Glosario: Short for “YAML Ain’t Markup Language”, a way to represent nested data using indentation. YAML is often used in configuration files and to define parameters for various flavours of Markdown documents.

Attribution

The plain-language definitions on this page were written for this course. The technical wording in the gray blocks is from Glosario by The Carpentries, licensed under CC-BY 4.0, in places shortened or adapted to the context of this workshop.