path: root/linux-command-line/shell-basics/index.md

---
title: Shell Basics
---

# Shell Basics

The shell is your primary interface to a Linux system. Everything — file management, process control, system administration — flows through it. Before graphical tools, before IDEs, there was the shell. Mastering it is non-negotiable.

**Prerequisites:** None
**Estimated time:** 4-6 hours of practice

---

## What is a Shell?

A shell is a program that reads commands from your input and executes them. It's both a **command interpreter** (runs programs) and a **programming language** (scripts).

Common shells:
- **bash** — Bourne Again Shell, the default on most Linux systems
- **zsh** — Extended bash with better completion and prompting
- **sh** — POSIX shell, the lowest common denominator
- **fish** — Friendly interactive shell, not POSIX-compatible

When you open a terminal, you're running a **terminal emulator** (alacritty, kitty, xterm) which hosts a **shell process**. The terminal draws pixels; the shell interprets commands.

```bash
# Check your current shell
echo $SHELL

# List available shells
cat /etc/shells

# The shell prompt typically shows:
# username@hostname:current_directory$
```

> **Key distinction:** The terminal and the shell are different things. You can run bash inside alacritty, or inside a Linux TTY, or over SSH. The shell doesn't care what's displaying its output.

---

## Navigating the Filesystem

Linux has a single filesystem tree rooted at `/`. Everything is a file — devices, processes, sockets.

### Essential Navigation Commands

```bash
pwd                     # Print working directory — where you are
ls                      # List files in current directory
ls -la                  # Long format, show hidden files (dotfiles)
ls -lh                  # Human-readable sizes (K, M, G)
cd /etc                 # Change to /etc
cd ~                    # Change to home directory (also just: cd)
cd -                    # Change to previous directory
cd ..                   # Go up one level
```

### The Filesystem Hierarchy

| Path | Purpose |
|------|---------|
| `/` | Root of everything |
| `/home` | User home directories |
| `/etc` | System configuration files |
| `/var` | Variable data (logs, databases, mail) |
| `/tmp` | Temporary files (cleared on reboot) |
| `/usr` | User programs and data (read-only) |
| `/usr/bin` | Most user commands |
| `/usr/local` | Locally installed software |
| `/dev` | Device files |
| `/proc` | Process information pseudo-filesystem |
| `/sys` | Kernel/device information pseudo-filesystem |
| `/opt` | Optional/third-party software |

```bash
# The filesystem is a tree. Explore it:
ls /
ls /etc
ls /dev

# Everything is a file:
file /dev/null          # character special device
file /etc/hostname      # ASCII text
file /usr/bin/ls        # ELF 64-bit executable
```

---

## File Operations

### Creating, Copying, Moving, Deleting

```bash
# Create
touch newfile.txt               # Create empty file (or update timestamp)
mkdir mydir                     # Create directory
mkdir -p path/to/nested/dir     # Create nested directories

# Copy
cp file.txt backup.txt          # Copy file
cp -r mydir/ mydir_backup/      # Copy directory recursively

# Move / Rename
mv old.txt new.txt              # Rename
mv file.txt ~/Documents/        # Move to another directory

# Delete
rm file.txt                     # Remove file (no trash, no undo)
rm -r mydir/                    # Remove directory recursively
rm -ri mydir/                   # Interactive — asks before each deletion
rmdir emptydir/                 # Remove only if empty
```

> **Warning:** `rm` is permanent. There is no trash can. `rm -rf /` will destroy your entire system if you have the permissions. Always double-check your path before pressing Enter.

### Viewing Files

```bash
cat file.txt                    # Print entire file to stdout
less file.txt                   # Paginated viewer (q to quit, / to search)
head -n 20 file.txt             # First 20 lines
tail -n 20 file.txt             # Last 20 lines
tail -f /var/log/syslog         # Follow a file in real-time (great for logs)
wc -l file.txt                  # Count lines
```

`less` is your friend. Use it for anything longer than a screenful. Key bindings inside `less`:
- `Space` / `b` — page down / up
- `/pattern` — search forward
- `n` / `N` — next / previous search match
- `g` / `G` — go to top / bottom
- `q` — quit

---

## Permissions

Every file has an **owner**, a **group**, and a set of **permissions** (read, write, execute) for each of: owner, group, others.

```bash
ls -l file.txt
# -rw-r--r-- 1 ahmed users 1234 Mar 31 10:00 file.txt
# │├──┤├──┤├──┤
# │ │    │   └── others: read only
# │ │    └────── group: read only
# │ └─────────── owner: read + write
# └───────────── file type: - = regular, d = directory, l = symlink
```

### chmod — Change Permissions

```bash
# Symbolic notation
chmod u+x script.sh            # Add execute for owner
chmod go-w file.txt            # Remove write for group and others
chmod a+r file.txt             # Add read for all

# Octal notation (most common)
chmod 755 script.sh            # rwxr-xr-x — owner full, others read+execute
chmod 644 file.txt             # rw-r--r-- — owner read+write, others read
chmod 600 secret.key           # rw------- — owner only
```

**Octal cheat sheet:** r=4, w=2, x=1. Add them up per group.
- `7` = rwx (4+2+1)
- `6` = rw- (4+2)
- `5` = r-x (4+1)
- `4` = r-- (4)
- `0` = --- (0)

### chown — Change Ownership

```bash
chown ahmed file.txt            # Change owner
chown ahmed:users file.txt      # Change owner and group
chown -R ahmed:users mydir/     # Recursive
```

### Directories and Execute Permission

The execute bit on directories means something different: it grants **access** (the ability to `cd` into it and access files within). A directory with `r--` lets you list filenames but not read the files. A directory with `--x` lets you access files by name but not list them.

---

## Pipes and Redirection

This is where the shell gets powerful. The Unix philosophy: small programs that do one thing well, connected together.

### Redirection

Every process has three standard streams:
- **stdin** (0) — input
- **stdout** (1) — normal output
- **stderr** (2) — error output

```bash
# Redirect stdout to a file
ls > filelist.txt               # Overwrite
ls >> filelist.txt              # Append

# Redirect stderr
gcc broken.c 2> errors.txt     # Errors go to file
gcc broken.c 2>&1              # Stderr merges into stdout

# Redirect both
command > output.txt 2>&1       # Both to same file
command &> output.txt           # Bash shorthand for the above

# Discard output
command > /dev/null 2>&1        # Silence everything

# Read stdin from a file
sort < unsorted.txt
```

### Pipes

Pipes connect stdout of one command to stdin of the next.

```bash
# Find the 10 largest files in /var/log
du -sh /var/log/* 2>/dev/null | sort -rh | head -10

# Count unique IP addresses in a log
cat access.log | awk '{print $1}' | sort | uniq -c | sort -rn | head -20

# Find running processes matching a pattern
ps aux | grep nginx | grep -v grep

# Chain as many as you need
cat /etc/passwd | cut -d: -f1 | sort | head -5
```

> **Useless use of cat:** `cat file | grep pattern` can be written as `grep pattern file`. But in pipelines with many stages, starting with `cat` can be clearer. Don't stress about it early on — clarity matters more than micro-optimization.

### Command Substitution

Use the output of one command inside another:

```bash
# Using $() — preferred
echo "Today is $(date +%Y-%m-%d)"
files=$(ls *.txt)

# Using backticks — older style, harder to nest
echo "Today is `date +%Y-%m-%d`"
```

---

## Wildcards (Globbing)

The shell expands patterns before passing them to commands:

```bash
*               # Match any characters (except leading dot)
?               # Match exactly one character
[abc]           # Match a, b, or c
[0-9]           # Match any digit
[!abc]          # Match anything except a, b, c
**              # Match directories recursively (bash: shopt -s globstar)

# Examples
ls *.txt                # All .txt files
ls file?.log            # file1.log, fileA.log, etc.
ls *.{jpg,png}          # All .jpg and .png files (brace expansion, not globbing)
rm /tmp/test_*          # All files starting with test_ in /tmp
```

---

## Getting Help

```bash
man ls                  # Manual page for ls (press q to quit)
man -k "copy files"     # Search manual descriptions
ls --help               # Quick help (most GNU tools)
type ls                 # Is it a builtin, alias, or binary?
which python            # Full path of a command
whatis ls               # One-line description
apropos network         # Search man pages by keyword
```

**Reading man pages:** The synopsis section uses conventions:
- `[optional]` — square brackets mean optional
- `REQUIRED` — caps or no brackets means required
- `...` — can be repeated
- `a | b` — choose one

---

## Exercises

### Drill Exercises

1. Navigate to `/etc` and list all files starting with `host`. What do they contain?
2. Create a directory structure: `~/practice/project/{src,docs,tests}` in one command
3. Create a file, set its permissions to 750, then explain who can do what with it
4. Use `ls -la /` and identify which entries are regular files, directories, and symlinks
5. Redirect the output of `ls /nonexistent` to `/dev/null` while keeping error messages visible

### Pipeline Challenges

6. Count how many lines in `/etc/passwd` contain the string `nologin`
7. List the 5 largest files in `/usr/bin` by size (hint: `ls -lS` or `du`)
8. Extract just the usernames from `/etc/passwd` (field 1, colon-separated) and sort them
9. Find all environment variables that contain the string `PATH` (hint: `env | grep`)
10. Get the total line count of all `.conf` files in `/etc/` (hint: `wc -l`, `cat`)

### Mini-Project

**Build a quick reference card:** Create a file `~/cheatsheet.md` that contains the 20 commands you found most useful from this section, organized by category, with a one-line description and example for each. This is your cheatsheet — you'll extend it throughout the course.

---

## Key Takeaways

- The shell is a command interpreter and a programming environment
- Everything in Linux is a file, organized in a single tree from `/`
- Permissions are the foundation of Linux security — understand `rwx` and octal
- Pipes and redirection are the core of composing commands
- `man` and `--help` are always available — read them first, search the web second
- Practice in a real terminal. Reading about commands is not the same as using them.

---

**Next:** [File Management](../file-management/) — find, locate, tar, rsync, and more