You type ls -la into a terminal and a directory listing appears. It feels as if the terminal itself ran the command, but another program did the interpreting.
That program is the shell. It reads text, decides which parts are commands and arguments, performs expansions and redirections, finds something to run, and reports the result. Bash is one widely used Linux shell, but it is not the only one.
Understanding this layer makes quoting, variables, scripts, pipelines, and command errors much less mysterious. This lesson builds that mental model without assuming you already know shell programming.
A terminal is the interface where text input and output appear. A shell is a command interpreter running inside that interface. Bash is a particular shell implementation.
The shell does more than launch programs: it interprets syntax, expands values, handles redirection, runs builtins, and makes commands reusable as scripts.
- How a terminal, shell, command, and process differ.
- What Bash does between reading a line and running a program.
- Why some commands are built into the shell.
- How quoting changes the arguments a command receives.
- How interactive commands become non-interactive shell scripts.
- 🧠 Terminal, Shell, and Command Are Different Layers
- Terminal
- Shell
- Command
- What Is Bash?
- 🔄 What Happens When You Press Enter?
- Read and parse the input
- Perform expansions
- Set up redirections
- Select and execute the command
- Collect an exit status
- Builtins, External Programs, Functions, and Scripts
- Why Quoting Is Part of Command Meaning
- Interactive Shells and Shell Scripts
- 🧪 Mini Lab: Observe the Shell’s Decisions
- 1. Start a clean practice shell
- 2. Inspect command types
- 3. Watch a builtin change shell state
- 4. Compare quoted and unquoted expansion
- 5. Inspect an exit status immediately
- 6. Run Bash non-interactively, then leave
- ⚠️ Common Shell Mistakes
- Short Summary
🧠 Terminal, Shell, and Command Are Different Layers
These words are often used as though they mean the same thing. They describe related parts of one interaction, but each part has a different job.
Terminal
Provides a text interface. It displays output and sends your keystrokes to the program attached to it.
Shell
Reads command language, interprets its syntax, and decides what actions to perform.
Command
An instruction expressed in shell syntax. It may invoke a builtin, function, executable program, or script.
A terminal window can host Bash, another shell such as Zsh, a text-based program, or a remote SSH session. Closing the terminal usually ends the interactive session associated with it, but terminal and shell remain separate concepts.
The shell itself is also a running program. When it starts an external command, that command normally becomes another process. This is why shell behavior connects directly to process management, signals, and environment inheritance.
What Is Bash?
Bash stands for Bourne-Again SHell. It is both a command interpreter and a programming language. In interactive use, it reads commands from your terminal. In non-interactive use, it can read commands from a file or a supplied string.
Linux does not require every user or system component to use Bash. Other shells have different features and startup rules. Syntax that works in Bash is not automatically valid in every shell, and a script should be written for the interpreter it actually uses.
Think of a shell as a language runtime placed between text and operating-system actions. The visible command line is only the input surface; interpretation is the shell’s real work.
🔄 What Happens When You Press Enter?
Suppose you enter this line:
printf '%s\n' "$HOME"The shell does not pass the entire line unchanged to a program. It processes the line in stages. The full rules have important details, but this simplified flow is a useful beginner model:
Read and parse the input
The shell separates words and operators according to shell syntax. Quotes affect which characters retain special meaning and which text stays together.
Perform expansions
In the example, $HOME requests a variable’s value. Other shell features can expand filenames, arithmetic expressions, or the output of another command.
Set up redirections
If the command redirects input or output, the shell prepares those connections before execution. Redirection symbols are shell syntax, not ordinary arguments passed unchanged to the command.
Select and execute the command
The shell determines whether the name refers to a function, builtin, or executable. For an external name without a slash, Bash can search directories listed in PATH.
Collect an exit status
A command returns a small integer status. By convention, zero indicates success and a non-zero value indicates some form of failure or false result whose meaning depends on the command.
The GNU Bash shell operation reference documents this sequence in more detail.
Builtins, External Programs, Functions, and Scripts
Not every command name refers to an executable file. The shell can resolve a name to several kinds of action.
| Form | Where it lives | Why it matters |
|---|---|---|
| Shell builtin | Implemented by the shell | Can directly change shell state; cd is the classic example. |
| External program | An executable file on the filesystem | Usually runs as a separate process when invoked. |
| Shell function | Defined in the current shell | Groups shell commands under a reusable name. |
| Shell script | A text file containing shell commands | Lets a shell execute a repeatable non-interactive procedure. |
cd needs to be a builtin because changing directory must affect the current shell. If a separate child process changed its own directory and exited, the parent shell would remain where it was.
Bash’s type builtin helps you inspect how a name is interpreted. The result depends on the current shell because functions, aliases, and command lookup can differ between sessions.
Why Quoting Is Part of Command Meaning
Quotes are instructions to the shell. They are normally removed during interpretation rather than passed as literal quote characters to the final command.
Double quotes allow expansions such as $HOME while keeping the expanded result together as one argument. Single quotes preserve their contents literally in Bash: a dollar sign inside single quotes does not request variable expansion.
printf '%s\n' "$HOME"
printf '%s\n' '$HOME'The first line normally prints your home-directory path. The second prints the four characters $HOME. Quoting is therefore not cosmetic punctuation; it changes the command the shell constructs.
Do not copy shell punctuation without understanding which program interprets it. Quotes, pipes, redirections, wildcards, and variable references are often handled by the shell before the selected command begins.
Interactive Shells and Shell Scripts
An interactive shell reads commands while you work and presents a prompt. It may provide history, line editing, aliases, and job control. A non-interactive shell can read commands from a script or string and then exit.
A shell script is not a recording of terminal pixels. It is a text file containing commands for an interpreter. Scripts can accept arguments, test conditions, repeat actions, and combine utilities, but those programming features should be learned after the execution model is clear.
A script often begins with an interpreter line such as #!/usr/bin/env bash. This line asks the operating system to use an interpreter found through env and its current PATH. That choice has portability and environment implications; it is not interchangeable with every possible shebang.
Values supplied to launched programs are covered separately in Linux Environment Variables Explained. The key connection is that the shell prepares a command’s execution environment before starting it.
🧪 Mini Lab: Observe the Shell’s Decisions
Use Bash on a Linux practice system. These commands change no files and require no administrator privileges. A nested shell keeps the experiment separate from your usual session.
1. Start a clean practice shell
bash --noprofile --norcWhat to observe: Bash starts without reading its usual interactive startup files. It still inherits an environment, so “no startup files” does not mean “no settings.”
2. Inspect command types
type cd
type printf
type lsWhat to observe: Bash should identify cd as a builtin. It commonly identifies printf as a builtin and ls as an external file, although exact paths and available definitions can vary.
3. Watch a builtin change shell state
pwd
cd /tmp
pwdHow to interpret it: The second path is /tmp because cd changed the current working directory of this practice shell. Paths and the directory hierarchy are explained in the Linux filesystem lesson.
4. Compare quoted and unquoted expansion
SA_WORDS='two words'
printf '<%s>\n' "$SA_WORDS"
printf '<%s>\n' $SA_WORDSWhat to observe: The quoted expansion is passed as one argument, so it produces one bracketed line. In this controlled example, the unquoted expansion is split into two arguments and produces two lines.
5. Inspect an exit status immediately
false
printf 'status: %s\n' "$?"What to observe: The status is normally 1. The special parameter $? holds the status of the most recent pipeline, so inspect it before running another command.
6. Run Bash non-interactively, then leave
bash -c 'printf "%s\n" "read from a command string"'
exitHow to interpret it: The nested Bash invoked with -c reads commands from a string and exits. The final exit closes your practice shell and returns you to the original session.
⚠️ Common Shell Mistakes
The terminal carries text input and output. The shell interprets command language and decides what to run.
A name can resolve to a builtin, function, script, or executable. Inspect the current shell’s interpretation instead of assuming.
The shell normally uses quotes to control interpretation and removes them. The resulting arguments—not the original visual line—are what a program receives.
Non-zero means the command did not report success. Some utilities use statuses to represent a false test or missing match; interpret the code in the context of that command.
Shells overlap but are not identical. Choose an interpreter deliberately and avoid running Bash-specific syntax under a different shell.
Short Summary
The terminal is the interface; the shell is the interpreter. Bash reads shell language interactively or non-interactively, transforms text through parsing and expansion, prepares redirections, selects a command, executes it, and records its status.
Once you see those stages, shell behavior becomes testable. You can ask whether a problem occurred during parsing, expansion, lookup, execution, or inside the program itself.
- What is the practical difference between a terminal and a shell?
- Why must
cdaffect the current shell rather than only a separate child process? - What happens to
$HOMEinside double quotes, and what happens inside single quotes? - Why can the same command name resolve differently in two Bash sessions?
- What does an exit status tell the shell, and why must you interpret non-zero values in context?
- How does a non-interactive shell differ from an interactive shell?
🎓 Check Your Answers
- A terminal provides the text input and output interface, while a shell interprets command language. The shell may run inside the terminal, but they perform different jobs.
- The current working directory belongs to the shell’s execution state. If only a child process changed directory and then exited, the parent shell’s location would remain unchanged.
- In Bash, double quotes still allow parameter expansion, so
$HOMEbecomes its value while remaining one argument. Single quotes preserve the text literally, so the dollar sign has no expansion role. - Sessions can contain different functions, aliases, builtins, remembered command locations, and
PATHvalues. Command lookup therefore depends on the current shell state. - The status is the command’s result code: zero conventionally means success, while non-zero reports another outcome. Its precise meaning belongs to the command, so a non-zero status is evidence to interpret rather than a universal diagnosis.
- An interactive shell exchanges commands with a user and commonly offers prompt-oriented features. A non-interactive shell reads commands from a script or supplied input and can execute them without a person entering each line.
A shell is the interpreter between command text and execution. It gives syntax meaning, prepares arguments and redirections, chooses what to run, and receives the result.
When a command surprises you, separate the layers: what the terminal displayed, what the shell interpreted, what executable or builtin ran, and what status it returned.
