Command line git

A full file location written from the top of the filesystem, so it points to the same file regardless of where you currently are. On Linux and macOS it starts with a slash; on Windows it begins with a drive letter such as C:.

Example. /home/asha/project/data/train.csv is an absolute path that works from any folder.

Related: Relative path, Root directory, Working directory

A custom short name the shell replaces with a longer command. It is defined with the alias keyword, usually in a shell profile so it persists. Aliases suit personal shortcuts but are not carried into scripts by default.

Example. alias ll='ls -alh' lets you type ll to see all files with details.

Related: Shell profile, Bash, Command-line flag

Modifying the most recent commit, by adding forgotten changes or correcting its message, so it replaces the previous commit instead of adding another one. It rewrites history, so avoid it after publishing the commit.

Example. git commit --amend -m 'Fix typo in README' changes the last commit message.

Related: Commit, Force push, Rebase

A small programming language for processing text in columns. It splits each line into fields, lets you filter lines by conditions and print or total chosen fields, making it ideal for quick reports on delimited files or logs.

Example. awk '{sum += $3} END {print sum}' sales.txt adds up the third column of every line.

Related: sed, grep, Pipe

A command started so the shell prompt returns immediately while it keeps running, usually by adding an ampersand. The jobs command lists them, and nohup keeps them alive after you close the terminal. Useful for long training runs.

Example. nohup python train.py > log.txt 2>&1 & starts training that survives closing the terminal.

Related: Redirection, cron

The Bourne Again Shell, the default shell on most Linux servers and the one most tutorials assume. It supports pipes, variables, loops, functions and scripts, so a series of manual steps can be saved in a file and repeated exactly.

Example. A Bash loop: for f in *.csv; do wc -l $f; done counts the lines in every CSV file in the folder.

Related: Shell, Shell script, Zsh

A Git search that finds the commit that introduced a bug by binary search. You mark one good and one bad commit, and Git repeatedly checks out the midpoint until it isolates the culprit in a logarithmic number of steps.

Example. Among 1,000 commits, git bisect needs about 10 tests to identify the one that broke accuracy.

Related: Git log, Commit, Blame

A command that shows, for each line of a file, the commit and author that last changed it. It helps trace why a line exists and who may know the context, rather than to assign fault.

Example. git blame train.py shows which commit introduced each line of the training script.

Related: Git log, Commit, Bisect

A movable label pointing to a commit that represents an independent line of development. New commits advance the branch you are on. Branches let you work on a feature or experiment without disturbing the stable code.

Example. git switch -c try-lora creates and moves to a new branch for a fine-tuning experiment.

Related: Merge, Main branch, Feature branch, HEAD

Copying one specific commit from one branch and applying it as a new commit on the current branch, without merging everything else. It is useful for moving a single bug fix to a release branch.

Example. git cherry-pick a1b2c3d applies that commit's change onto your current branch.

Related: Commit, Branch, Rebase

A command that changes the permission settings of files. It accepts symbolic forms such as u+x or octal numbers where read is 4, write is 2 and execute is 1 per group. It is often needed to make a script runnable.

Example. chmod +x run.sh makes a script executable; chmod 600 key.pem lets only the owner read and write it.

Related: File permissions, Shebang, SSH key

Creating a full local copy of a remote repository, including all history and branches, and setting it up to track the source. It is the first step for working on an existing project.

Example. git clone https://github.com/huggingface/transformers.git downloads the project folder to your machine.

Related: Repository, Remote, Fork, Fetch

The practice of having teammates read proposed changes before they are merged, to catch bugs, improve design and share knowledge. Reviewers leave comments and approve or request changes. It is standard in professional teams.

Example. A reviewer notices a missing null check and asks for a fix before approving the pull request.

Related: Pull request, Diff, Protected branch

A value supplied after a command name that tells it what to act on, such as a file name or a URL. The program reads arguments in order. Unlike options, arguments are usually required and their meaning depends on their position.

Example. In cp report.pdf backup/, report.pdf and backup/ are the two arguments.

Related: Command-line flag, Command-line interface, Shell script

The shell's saved list of commands you have run before, which you can browse with the up arrow, list with the history command or search with Ctrl+R. It speeds up repeating long commands but may accidentally store secrets typed inline.

Example. Pressing Ctrl+R and typing docker brings back your last command containing docker.

Related: Tab completion, Shell, Shell profile

An option given to a command, starting with a dash (short form, -v) or two dashes (long form, --verbose), that changes how it behaves. Flags can be switches or take a value. Reading a tool's help output is the way to learn its flags.

Example. ls -lh lists files in long format with human-readable sizes, and pip install --upgrade pandas forces an update.

Related: Command argument, Man page, Command-line interface

A way of operating a computer by typing text instructions and reading text replies, instead of clicking icons. Each instruction names a program and its options. It is faster to repeat, easy to automate in scripts, and is the normal way to reach remote servers and cloud machines.

Example. Typing ls -l in a terminal to list files with sizes, rather than opening a folder window.

Related: Shell, Terminal, Shell script

A saved snapshot of the tracked files at one moment, with a message, author, timestamp and a pointer to its parent commit. Commits form the history chain. Small commits with clear messages make changes easy to review and undo.

Example. git commit -m 'Add train/test split' records the staged changes as a new snapshot.

Related: Staging area, Commit hash, Repository, Amend

A 40-character hexadecimal identifier computed from a commit's contents and metadata that uniquely names it. Any change to the commit produces a different one. Git accepts short prefixes, usually seven characters, to refer to them.

Example. git show a1b2c3d displays the commit whose hash starts with a1b2c3d.

Related: Commit, Git, Reflog

The practice of automatically building and testing a project every time changes are pushed, so that errors are found within minutes and not at release time. It relies on a shared repository and automated tests.

Example. Each pull request triggers a job that installs dependencies, runs unit tests and reports success or failure.

Related: GitHub Actions, Pull request, Exit status, Pre-commit hook

A convention for commit messages using a type prefix such as feat, fix or docs, an optional scope and a short description. Tools can read them to build changelogs and choose version numbers.

Example. feat(api): add streaming endpoint or fix: handle empty prompt.

Related: Commit, Semantic versioning, Release

A Unix scheduler that runs commands automatically at set times, defined by lines in a crontab with five time fields for minute, hour, day of month, month and weekday. It is used for recurring jobs such as backups and data refreshes.

Example. 0 2 * * * python refresh.py runs the script every day at 2:00 am.

Related: Shell script, Exit status, Background job

A command-line tool that sends requests to URLs using HTTP and other protocols and prints or saves the response. Developers use it to test APIs, download files and check headers without writing a program.

Example. curl -H 'Authorization: Bearer $TOKEN' https://api.example.com/v1/models fetches a JSON list from an API.

Related: Command-line flag, Pipe, Environment variable

A state where the checked-out position is a specific commit rather than a branch. New commits made there belong to no branch and can be lost unless you create a branch for them.

Example. git checkout a1b2c3d puts you here; git switch -c rescue keeps any new commits you make.

Related: HEAD, Branch, Reflog

A line-by-line comparison showing what was added and removed between two versions of files. Git can compare the working tree, the staging area, commits or branches, and pull requests display it for review.

Example. git diff shows unstaged changes, with lines starting with + added and - removed.

Related: Commit, Code review, Staging area

A plain text file, conventionally named .env, holding KEY=value lines of configuration such as API keys and database URLs. Libraries load it into environment variables at start-up. It should be excluded from version control so secrets are not published.

Example. A .env file with DATABASE_URL=postgres://localhost/app is read by python-dotenv, and .env is listed in .gitignore.

Related: Environment variable, Gitignore, Secret leakage

A file or folder whose name begins with a dot, which most tools hide from ordinary listings. They typically store configuration for shells, editors and tools. Use ls -a to see them.

Example. ~/.gitconfig, ~/.zshrc and ~/.ssh are dotfiles in a home directory.

Related: Home directory, Shell profile, Gitignore

A named value stored in the environment of a process and inherited by the programs it launches. Programs read them to pick up settings such as paths, modes and credentials without changing code, which keeps configuration separate from source.

Example. export OPENAI_API_KEY=sk-... lets a Python script read the key with os.environ['OPENAI_API_KEY'].

Related: PATH, Dotenv file, Shell profile

A small number a program returns when it finishes: 0 signals success and any other value signals a failure kind. The shell stores it in the variable $?, and scripts or CI systems use it to decide whether to continue.

Example. After grep -q hello file.txt, echo $? prints 0 if the word was found and 1 if not.

Related: Shell script, Standard error, Continuous integration

A kind of merge where the target branch has no new commits of its own, so Git simply moves its pointer forward to the incoming branch's latest commit. No merge commit is created and history stays a straight line.

Example. If main has not changed since you branched, merging your branch just moves main to your last commit.

Related: Merge, Branch, Rebase

A short-lived branch created to develop one feature or fix, then merged back to the main line after review. It isolates unfinished work so the main branch stays stable. It keeps each piece of work reviewable on its own.

Example. A branch named feature/add-rag-eval holds all commits for a new evaluation script until it is reviewed.

Related: Branch, Pull request, Main branch

Downloading new commits and branches from a remote without changing your working files or current branch. It lets you inspect what others have done before deciding to merge it. It is the safe first step before combining anything.

Example. git fetch origin updates origin/main, and git log main..origin/main lists the new commits.

Related: Pull, Remote, Merge

The record of which user account and which group a file belongs to, which decides which permission set applies to whoever is accessing it. The chown command changes it. Wrong ownership often appears after running commands with elevated rights.

Example. ls -l shows asha staff beside a file, meaning user asha and group staff own it.

Related: File permissions, chmod, Superuser

Settings on each file that say who may read, write or execute it. They are split into three groups: the owner, the owner's group and everyone else. Correct permissions protect data and are a frequent cause of Permission denied errors.

Example. -rw-r--r-- means the owner can read and write, while group and others may only read.

Related: chmod, File ownership, Superuser

A command that walks through folders and lists files matching conditions such as name, size, type or modification time, optionally running another command on each. It searches by file properties rather than by file contents.

Example. find . -name '*.ipynb' -size +1M lists notebooks larger than one megabyte under the current folder.

Related: grep, Glob pattern, xargs

A push that overwrites the remote branch with your local version even when that discards commits others may have. It is needed after rewriting history, and the safer option --force-with-lease refuses if the remote changed unexpectedly.

Example. After rebasing your own feature branch, git push --force-with-lease updates the remote copy.

Related: Rebase, Amend, Protected branch, Push

A personal copy of someone else's repository made on a hosting platform under your own account. You can change it freely, and offer changes back to the original through a pull request. It is the standard way to contribute to open-source projects.

Example. You fork an open-source library to your GitHub account, fix a typo, and open a pull request to the original.

Related: Pull request, Clone, GitHub, Upstream

The most widely used distributed version control system. Every developer holds a full copy of a project's history locally, so most operations work offline and are fast. Git stores snapshots of files and supports cheap branching and merging.

Example. git init in a folder starts tracking it, and git log shows its history.

Related: Repository, Commit, Branch, GitHub

Git Large File Storage, an extension that keeps big binary files such as datasets or model weights outside the normal repository, storing small pointer files in Git instead. It keeps clones fast, though hosting limits still apply.

Example. git lfs track '*.bin' makes Git store model weight files through LFS instead of directly.

Related: Repository, Gitignore, Clone

A command that lists commit history in reverse order, showing hash, author, date and message. Options can condense it to one line per commit, draw a branch graph or filter by author and file.

Example. git log --oneline --graph shows a compact view of branches and merges.

Related: Commit, Commit hash, Blame

A web platform that hosts Git repositories and adds collaboration tools such as pull requests, issues, code review, automation and project boards. It is the main place for sharing open-source code and showing your work to employers.

Example. You push a project to GitHub and put its link on your CV.

Related: Git, Pull request, Fork, GitHub Actions

GitHub's built-in automation service that runs workflows defined in YAML files in response to events such as pushes or pull requests. It is used to run tests, build images and deploy without managing servers.

Example. A workflow file runs pytest on every pull request and shows a red cross if any test fails.

Related: Continuous integration, Pull request

A text file named .gitignore listing file patterns that Git should not track, such as build outputs, virtual environments, large data and secrets. It keeps repositories small and prevents accidental leaks.

Example. A .gitignore with .venv/, __pycache__/, .env and *.pt keeps environments, caches, secrets and model weights out of commits.

Related: Dotenv file, Repository, Staging area

A shorthand for matching many file names at once using wildcard characters, expanded by the shell before the command runs. An asterisk matches any run of characters and a question mark matches exactly one. It is simpler than but different from regular expressions.

Example. rm *.tmp deletes every file in the folder whose name ends in .tmp; ls data_??.csv matches data_01.csv but not data_100.csv.

Related: Regular expression, find, Shell

A command that searches text files or piped input for lines matching a word or regular expression and prints them. Flags allow case-insensitive search, line numbers and recursive search through folders. It is a daily tool for logs and code.

Example. grep -rn 'learning_rate' src/ lists every place in the src folder where learning_rate appears, with line numbers.

Related: Regular expression, Pipe, find, sed

A pointer showing which commit or branch is currently checked out, and hence the parent of your next commit. Usually it points to a branch name, which in turn points to the latest commit.

Example. HEAD~1 refers to the commit just before the current one, and git diff HEAD compares against the latest commit.

Related: Branch, Detached HEAD, Commit

The personal folder assigned to a user account, where documents and user-level settings are kept. The tilde character stands for it in most shells. New terminal sessions usually start there, and configuration files such as shell profiles live in it.

Example. cd ~ takes you to /home/asha on Linux or /Users/asha on macOS.

Related: Working directory, Root directory, Shell profile

A tracked item on a hosting platform used to report a bug, request a feature or discuss a task. Issues have titles, discussion, labels and assignees, and can be linked to pull requests that resolve them.

Example. Opening an issue titled Tokenizer crashes on empty string, and closing it with a pull request that says Fixes #42.

Related: Pull request, GitHub, Release

The default branch of a repository that holds the stable, up-to-date version of the project, historically called master and now usually named main. Teams protect it and merge tested work into it.

Example. Deployments are built from main, while new work happens on separate branches.

Related: Branch, Protected branch, Trunk-based development

The built-in manual for a command on Unix-like systems, opened by typing man followed by the command name. It explains the syntax, options and sometimes examples, and is available offline. Many tools also offer a shorter summary through --help.

Example. man grep opens the manual for grep; press q to quit and / to search inside it.

Related: Command-line flag, grep, Shell

Combining the changes from one branch into another so that their histories join. Git creates a merge commit when both branches have moved on, or just advances the pointer when possible.

Example. On main, git merge feature-x brings in the commits from feature-x.

Related: Merge conflict, Fast-forward, Pull request, Rebase

A situation where two branches changed the same part of a file in different ways, so Git cannot decide which to keep. It marks the file with conflict markers and waits for you to edit, stage and finish the merge.

Example. Two people change the learning rate on the same line; Git inserts <<<<<<<, ======= and >>>>>>> markers until one value is chosen.

Related: Merge, Rebase, Pull request

A single repository holding the code of many projects or services, rather than one per project. It simplifies sharing code and coordinated changes, but needs tooling to keep builds and permissions manageable.

Example. One repository contains a company's web app, data pipelines and shared utilities in separate folders.

Related: Repository, Submodule, Continuous integration

A legal text in a repository stating what others may do with the code, such as use, modify and redistribute. Common ones are MIT, Apache 2.0 and GPL, which differ in obligations. Without one, others have no clear permission.

Example. Adding an MIT LICENSE file lets anyone reuse your code provided they keep the copyright notice.

Related: Repository, README, GitHub

The conventional default name for the remote that a repository was cloned from. It is only a label, so it can be renamed, but tutorials and tools assume it. It appears in commands like push and pull.

Example. git push origin main sends the local main branch to the remote called origin.

Related: Remote, Clone, Push

A tool that downloads, installs, upgrades and removes software while tracking its dependencies. System ones include apt on Ubuntu and Homebrew on macOS; language ones include pip for Python and npm for JavaScript.

Example. sudo apt install git installs Git on Ubuntu, and brew install git does the same on macOS.

Related: sudo, PATH, Windows Subsystem for Linux

An environment variable holding a colon-separated list of folders, searched in order when you type a command name without a full path. If a program's folder is missing from it, the shell reports command not found even though the program is installed.

Example. Adding export PATH=$HOME/.local/bin:$PATH lets you run tools installed by pip install --user.

Related: Environment variable, Shell profile, Package manager

A generated secret string used in place of a password to authenticate to GitHub from the command line or scripts. It can be limited to certain actions and revoked at any time, so it should be stored safely.

Example. git clone over HTTPS asks for a username and a token instead of your account password.

Related: SSH key, Secret leakage, Environment variable

A shell feature, written as a vertical bar, that connects the output of one command directly to the input of the next. It lets small single-purpose tools be combined into powerful one-line workflows without temporary files.

Example. cat access.log | grep 404 | wc -l counts how many log lines contain 404.

Related: Standard output, Standard input, Redirection, grep

A Microsoft shell and scripting language that passes structured objects between commands rather than plain text. It ships with Windows and also runs on Linux and macOS. Its command names differ from Bash, so Windows learners often use it or Windows Subsystem for Linux.

Example. Get-ChildItem lists files in the current folder, similar to ls in Bash.

Related: Shell, Bash, Windows Subsystem for Linux

A script that Git runs automatically before finishing a commit, and aborts the commit if it fails. Teams use it to run formatters, linters or secret scanners so problems are caught before code is shared.

Example. A hook in .git/hooks/pre-commit runs a formatter and blocks the commit if a file would change.

Related: Commit, Continuous integration, Secret leakage

A branch with rules enforced by the hosting platform, such as requiring reviews and passing checks before merging, and blocking force pushes or deletion. It stops accidental damage to important branches.

Example. main requires one approval and passing tests before any pull request can merge.

Related: Main branch, Force push, Code review, Continuous integration

Bringing a remote branch's new commits into your current branch: a fetch followed by a merge, or by a rebase if configured. It keeps your local copy up to date with teammates' work.

Example. git pull origin main updates your local main with the latest team changes.

Related: Fetch, Push, Merge, Remote

A request, made on a hosting platform, to merge one branch into another. It shows the changes, lets teammates comment and approve, and can trigger automated tests before merging. It is the centre of team code review.

Example. You push feature-x and open a pull request into main; two reviewers approve it and it is merged.

Related: Code review, Merge, Fork, Feature branch

Uploading your local commits to a remote repository so others can see them. Git rejects the push if the remote branch has commits you do not have, so you usually pull first.

Example. git push origin feature-x publishes your branch to GitHub.

Related: Pull, Remote, Force push, Pull request

Wrapping text in single or double quotes, or escaping it with a backslash, so the shell treats special characters as plain text. Single quotes keep everything literal; double quotes still allow variable expansion. It is essential for file names containing spaces.

Example. cp 'my notes.txt' backup/ works, while cp my notes.txt backup/ fails because the shell sees two separate file names.

Related: Glob pattern, Environment variable, Shell script

The front-page text file of a project, usually README.md, explaining what it does, how to install and run it, and how to contribute. It is the first thing visitors and recruiters read.

Example. A README with a one-line summary, setup commands, an example run and a results table for a portfolio project.

Related: Repository, GitHub

Replaying your branch's commits on top of another branch's latest commit, producing new commits with a straight-line history. It tidies history but rewrites it, so it should not be applied to commits others already use.

Example. git rebase main on a feature branch puts your commits after the newest main commits.

Related: Merge, Force push, Squash, Cherry-pick

Sending a command's input or output to or from a file instead of the screen or keyboard. The > symbol writes, overwriting the file, >> appends and < reads. Number prefixes such as 2> select the error channel.

Example. ls > files.txt saves a directory listing; ls >> files.txt adds another listing to the end.

Related: Pipe, Standard output, Standard error

A local log of where HEAD and branch tips have pointed recently, including moves caused by resets and rebases. It is the safety net for recovering commits that seem lost.

Example. After a bad hard reset, git reflog lists earlier positions, and git reset --hard HEAD@{2} restores one.

Related: HEAD, Reset, Detached HEAD

A compact pattern language for matching text, using symbols such as . for any character, * for repetition and [0-9] for a digit class. Shell tools, editors and programming languages use it to find, validate and extract text.

Example. The pattern ^[0-9]{6}$ matches exactly six digits, such as an Indian PIN code like 560001.

Related: grep, sed, Glob pattern

A file location described starting from the current folder instead of the top of the filesystem. The name .. means the parent folder and . means the current one. Relative paths keep projects portable but break if you run a script from an unexpected folder.

Example. From /home/asha/project, ../notes.txt refers to /home/asha/notes.txt.

Related: Absolute path, Working directory, Home directory

A packaged, named version of a project published for users, usually tied to a tag, with notes explaining changes. On hosting platforms it can also carry downloadable files. Release notes help users decide whether to upgrade.

Example. GitHub Releases lists v1.2.0 with a changelog and a downloadable wheel file.

Related: Tag, Semantic versioning, Conventional Commits

A named reference to a copy of the repository hosted elsewhere, such as on GitHub, that you can fetch from and push to. The usual default name is origin. A repository can have several.

Example. git remote add origin https://github.com/asha/project.git links your local repository to the hosted one.

Related: Clone, Push, Fetch, Fork

A project folder together with the full recorded history that Git keeps in a hidden .git directory. It holds every commit, branch and tag. A local copy and a hosted copy on a server are both called that.

Example. Running git clone downloads a repository with all its history to your machine.

Related: Git, Clone, Remote, Commit

A command that moves the current branch pointer to another commit and, depending on mode, also updates the staging area and working files. Soft keeps changes staged, mixed unstages them, and hard discards them.

Example. git reset --soft HEAD~1 undoes the last commit but keeps its changes staged.

Related: Revert, Reflog, HEAD, Commit

Undoing a commit by creating a new commit that applies the opposite changes. Unlike reset it leaves history intact, so it is the safe way to undo something already shared with others.

Example. git revert a1b2c3d adds a commit that cancels the changes of a1b2c3d.

Related: Reset, Commit, Cherry-pick

The single top-level folder of a Unix-style filesystem, written as a slash, containing every other folder. It should not be confused with the root user, who is an account with unlimited rights. Ordinary users are normally barred from changing most of it.

Example. cd / moves you to the top, where you will see folders such as etc, usr and home.

Related: Absolute path, Superuser, Home directory

A file synchronisation command that copies only the differences between source and destination, over the network or locally. It resumes interrupted transfers and preserves permissions, so it is efficient for repeated backups and large datasets.

Example. rsync -avz data/ ubuntu@server:/data/ mirrors a local folder to a server, sending only new or changed files.

Related: scp, SSH, Command-line flag

A command that copies files between your computer and a remote machine over SSH, keeping the transfer encrypted. It is simple for one-off transfers, while rsync is better when repeating large or partial transfers.

Example. scp model.pt ubuntu@203.0.113.10:/home/ubuntu/ uploads a file to a remote server.

Related: SSH, rsync, SSH key

Accidentally exposing credentials such as API keys or tokens, commonly by committing them to a repository. Even after deletion, they remain in history and may be scraped, so exposed keys must be revoked and replaced.

Example. An OpenAI key pushed in a config file to a public repo is quickly abused; the owner must revoke it immediately.

Related: Dotenv file, Gitignore, Personal access token, Pre-commit hook

A stream editor that changes text as it flows through, applying rules such as substitution to each line without opening a file interactively. It is commonly used for quick find-and-replace in scripts and pipelines.

Example. sed 's/foo/bar/g' notes.txt prints the file with every foo replaced by bar.

Related: grep, awk, Pipe

A numbering scheme MAJOR.MINOR.PATCH where a major bump signals breaking changes, minor adds compatible features and patch makes compatible fixes. It tells users how risky an upgrade is. Package managers use it to decide which upgrades are safe.

Example. Going from 2.3.4 to 2.4.0 adds features without breaking; going to 3.0.0 may break existing code.

Related: Tag, Release, Conventional Commits

The first line of a script, beginning with #! and naming the interpreter that should run the file. With execute permission set, the system uses it to launch the right program when you call the script directly.

Example. #!/usr/bin/env python3 on the first line lets ./train.py run under Python 3.

Related: Shell script, chmod, File permissions

A program that reads the commands you type, starts the programs they name and shows the results. It also provides variables, pipes, loops and scripting. Bash, Zsh and PowerShell are common ones, and the choice affects small syntax details of your commands.

Example. Typing echo $SHELL prints the path of the shell you are using, such as /bin/bash.

Related: Bash, Zsh, Terminal, Command-line interface

A startup file such as ~/.bashrc, ~/.bash_profile or ~/.zshrc that a shell reads when it starts, used to define aliases, PATH changes and environment variables. Edits take effect in new sessions or after running source on the file.

Example. Adding alias gs='git status' to ~/.zshrc and running source ~/.zshrc makes gs available immediately.

Related: Alias, PATH, Environment variable

A text file containing a sequence of shell commands run together, often with variables, conditions and loops. It automates repetitive tasks such as setup, data downloads or deployment, and gives you a repeatable record of what was done.

Example. A setup.sh containing python -m venv .venv, then source .venv/bin/activate, then pip install -r requirements.txt.

Related: Shebang, Bash, chmod, Exit status

Combining several commits into one, either during interactive rebase or when merging a pull request. It produces a shorter, cleaner history by hiding messy intermediate commits like fixes and typos.

Example. Five work-in-progress commits on a branch are squashed into one titled Add data validation.

Related: Rebase, Commit

Secure Shell, a protocol for logging into and running commands on a remote machine over an encrypted connection. It authenticates with a password or, better, a key pair. It is the standard way to reach cloud servers and GPU machines.

Example. ssh ubuntu@203.0.113.10 opens a shell on a remote cloud server.

Related: SSH key, scp

A pair of linked files used for passwordless login: a private key kept secret on your machine and a public key placed on the server or GitHub. The server checks that you hold the matching private key, without it being sent.

Example. ssh-keygen -t ed25519 creates the pair, and you paste id_ed25519.pub into GitHub settings to push code without typing a password.

Related: SSH, Personal access token

An intermediate zone where you choose which modified files or pieces of them go into the next commit. It lets you group related changes into one snapshot instead of saving every edit together.

Example. git add clean.py stages one file; running git commit afterwards records only that file.

Related: Commit, Working tree, Git

A second output channel reserved for warnings and error messages, kept separate from normal results so errors are not mixed into data being piped or saved. It can be redirected independently.

Example. python job.py > out.log 2> err.log saves results and errors in two files.

Related: Standard output, Redirection, Exit status

The default channel from which a program reads incoming data, normally the keyboard but replaceable by a file or the output of another command. Programs that read from it can be chained in pipelines without any file handling.

Example. In cat log.txt | grep ERROR, grep gets the text of log.txt on its standard input.

Related: Standard output, Pipe, Redirection

The default channel a program writes its normal results to, usually shown on screen but redirectable to a file or the next command. Keeping results here and messages elsewhere lets programs be combined cleanly.

Example. echo hello writes hello to standard output; echo hello > out.txt sends it into a file instead.

Related: Standard error, Pipe, Redirection

A temporary shelf where Git stores uncommitted changes and restores a clean working tree, so you can switch tasks and bring the changes back later. It works like a small stack of saved changes.

Example. git stash saves half-done edits, and git stash pop restores them after you fix an urgent bug on another branch.

Related: Working tree, Branch, Commit

A way to embed another Git repository inside a project at a fixed commit, keeping its history separate. It is used to include shared code but needs extra commands to update, and clones need the --recursive option.

Example. git submodule add <url> libs/tokenizer places another repository under libs/tokenizer.

Related: Repository, Monorepo, Clone

A command that runs a single instruction with the rights of another user, most often the superuser, after checking your password and permissions. It is safer than staying logged in as an administrator, but should be used carefully.

Example. sudo apt update refreshes the system package lists; running it without sudo fails with Permission denied.

Related: Superuser, Package manager, File permissions

The all-powerful administrative account on Unix-like systems, called root, which can read, change or delete any file and manage all processes. Working as this account is risky, so people use it only briefly for administrative tasks.

Example. Installing a system-wide package needs superuser rights, whereas editing your own notes does not.

Related: sudo, File permissions, Root directory

A shell feature where pressing the Tab key finishes a partly typed command, file name or path, or lists the possibilities. It saves typing, avoids spelling mistakes and helps you discover what files or options exist.

Example. Typing cd proj and pressing Tab completes it to cd project/ if that is the only match.

Related: Command history, Shell, Working directory

A fixed, human-readable name attached to one commit, typically marking a release. Unlike a branch it does not move as new commits arrive. Annotated tags also store a message and the tagger.

Example. git tag -a v1.0.0 -m 'First release' marks the commit deployed to production.

Related: Release, Semantic versioning, Commit

A command that bundles many files and folders into one archive file, optionally compressed with gzip. Datasets and source code are commonly distributed as .tar.gz files, and the same tool unpacks them.

Example. tar -czf project.tar.gz project/ creates a compressed archive; tar -xzf project.tar.gz extracts it.

Related: Command-line flag, scp, Shell

A window application that displays a text session and passes your keystrokes to a shell. It is only the display and keyboard layer; the shell inside does the real work. Editors such as VS Code embed one so you can run commands next to your code.

Example. Opening the integrated terminal in VS Code with Ctrl+` to run python train.py.

Related: Shell, Command-line interface

A workflow where developers merge small changes into one main branch frequently, often daily, and keep other branches very short-lived. It reduces painful merges and pairs with automated tests and feature flags.

Example. A team merges tiny changes to main several times a day, with tests running on each merge.

Related: Main branch, Continuous integration

The original repository or branch that your copy follows and takes updates from. For a fork, it usually means the source project, tracked as a second remote so you can bring in its newest changes.

Example. git remote add upstream <original-url> followed by git fetch upstream lets you update your fork.

Related: Fork, Remote

A system that records every change to a set of files over time so you can see who changed what and why, compare versions and restore an earlier one. It allows many people to work on the same project without overwriting one another.

Example. A team fixes a bug in a preprocessing script, and can later see the exact edit and roll it back if it caused problems.

Related: Git, Repository, Commit

A Windows feature that runs a real Linux environment beside Windows, giving you Bash, Linux tools and package managers without a separate virtual machine or dual boot. It is popular among learners on Windows because most AI tooling and tutorials assume Linux commands.

Example. A student on a Windows laptop installs Ubuntu under it and runs pip install and git commands exactly as in a Linux tutorial.

Related: Bash, Package manager, PowerShell

The folder a running shell or program treats as its current location. Relative paths are resolved against it, so the same command can behave differently depending on where you are. The pwd command prints it and cd changes it.

Example. If the working directory is /home/asha/project, then reading data/train.csv opens /home/asha/project/data/train.csv.

Related: Relative path, Absolute path, Home directory

The actual files and folders you see and edit on disk, corresponding to the checked-out version plus any uncommitted changes. Git compares it with the staging area and the last commit to report what has changed.

Example. After editing app.py, git status lists it as modified in the working tree but not yet staged.

Related: Staging area, Commit, Repository

A command that reads items from its input and passes them as arguments to another command, splitting them into batches when the list is long. It bridges tools that print lists and tools that expect arguments.

Example. find . -name '*.tmp' | xargs rm deletes every temporary file that find lists.

Related: find, Pipe, Command argument

A shell similar to Bash with extra conveniences such as smarter tab completion and themes. It is the default login shell on recent macOS. Most Bash commands work unchanged, though a few scripting details differ.

Example. On a MacBook, opening Terminal starts Zsh, and your settings live in the file ~/.zshrc.

Related: Bash, Shell, Shell profile