🐧 Ubuntu Command Line Interface: A Complete Tutorial

The Shell & the Prompt

When you open a terminal, you're talking to a program called the shell. On Ubuntu that's usually Bash (the Bourne Again SHell). The shell reads what you type, hands the instruction to the operating system, and prints the result. The window it runs in is the terminal; people use "terminal," "shell," and "command line" almost interchangeably.

Open one with Ctrl + Alt + T, or search "Terminal" in the applications menu. On Windows, install WSL (Windows Subsystem for Linux) to get a genuine Ubuntu shell — nearly every backend tool assumes this environment.

Reading the prompt

username@hostname:~$

When a tutorial shows $ ls, the $ just represents the prompt — you type only ls.

Command Structure

Almost every command follows one shape:

command [options] [arguments]

• command — the program to run (ls, cp, grep)
• options — flags that change behavior, prefixed with - or --
• arguments — what the command acts on (filenames, paths, text)

For example, in ls -la /home: ls is the command, -la are two options combined (long format plus all files), and /home is the directory argument.

Navigating the Filesystem

Ubuntu's files live in one unified tree that starts at the root, / — there are no C: or D: drive letters. Navigating is like walking through a building: you're always standing in one room, and you can look around or move to another.

pwd — where am I?

pwd
# /home/username

ls — what's here?

ls           # names only
ls -l        # long form: permissions, owner, size, date
ls -la       # long form AND hidden dotfiles
ls -lh       # long form with human-readable sizes (KB, MB)

cd — move around

cd Documents       # step into a folder
cd ..              # up one level to the parent
cd ~               # jump home
cd /var/log        # absolute path from the root
cd -               # jump back to the previous directory

Managing Files & Folders

Create: mkdir and touch

mkdir my-project              # one new folder
mkdir docs images styles       # several at once
mkdir -p src/components/ui      # -p builds the whole nested path

touch notes.txt                # create an empty file
touch index.html style.css     # create several

The -p ("parents") flag creates every missing folder in a path instead of failing because a middle folder doesn't exist yet.

Copy & move: cp and mv

cp report.txt backup.txt        # copy a file (original stays)
cp -r templates/ new-project/    # -r copies a whole folder tree

mv report.txt documents/         # move a file into a folder
mv report.txt final.txt          # rename (move to a new name)

mv does double duty: moving and renaming are the same operation — renaming is just "move to the same folder under a new name." The key difference from cp: mv leaves nothing behind, while cp keeps the original.

Delete: rm and rmdir

rm notes.txt                 # delete a file
rm -r old-project/            # -r deletes a folder and its contents
rm -ri old-project/           # -i asks before each deletion (safer)
rmdir empty-folder/           # only removes an EMPTY folder

Viewing & Searching Text

cat, less, head, tail

cat notes.txt                # print a whole (small) file
less big.log                 # page through a large file (q to quit)
head -n 20 data.csv          # first 20 lines
tail -n 50 app.log           # last 50 lines
tail -f /var/log/syslog      # follow a log live as it grows

tail -f is the one you'll reach for constantly when debugging a running server — it streams new log lines as they appear.

grep — search inside files

grep "ERROR" app.log            # lines containing ERROR
grep -i "error" app.log         # case-insensitive
grep -rn "TODO" src/            # recursive, with line numbers
grep -c "404" access.log        # count matching lines

find — search for files

find . -name "*.js"                    # every .js file below here
find . -type d -name "node_modules"     # directories with that name
find /home -type f -size +100M          # files larger than 100 MB
find . -type f -mtime -7                 # modified in the last 7 days

The . means "start in the current directory," -name matches the filename (quote the wildcard so the shell doesn't expand it first), and -type f/-type d restrict to files or directories.

Permissions & Ownership

Every file has permissions for three groups — the owner, the group, and others — across three actions: read, write, and execute. Run ls -l and you'll see them as a string like -rwxr-xr--.

chmod — change permissions

The numeric ("octal") form adds up read (4), write (2), and execute (1) for each group. So 7 is read+write+execute, 5 is read+execute, 4 is read-only.

chmod +x deploy.sh           # make a script executable
chmod 755 deploy.sh          # rwx for owner, r-x for group and others
chmod 644 config.json        # rw- for owner, r-- for everyone else
chmod -R 755 public/         # apply recursively to a folder

chown — change ownership

sudo chown username file.txt            # change the owner
sudo chown username:group file.txt      # change owner and group
sudo chown -R www-data:www-data /var/www # recursive, for web files

Pipes & Redirection

The real power of the shell is combining small commands. A pipe (|) feeds one command's output into the next; redirection (>, >>) sends output to a file.

Redirection

command > out.txt      # write output to a file (overwrite)
command >> out.txt     # append to a file
command 2> err.txt     # redirect only errors
command > out.txt 2>&1 # both output and errors to one file

Pipes

ls -la | grep ".txt"                 # list, then keep only .txt lines
cat access.log | wc -l               # count lines in a file
du -h | sort -rh | head -10          # ten biggest items, largest first
history | grep git                    # find past git commands

Packages & Services

apt — install software

Ubuntu manages software with apt. Update the package lists first, then install.

sudo apt update                 # refresh the list of available packages
sudo apt upgrade                # upgrade installed packages
sudo apt install nodejs npm     # install packages
sudo apt remove package-name    # remove a package
apt search keyword              # search for a package

sudo ("superuser do") runs a command with administrative rights — required for anything that changes the system, like installing software.

systemctl — manage services

systemctl status nginx          # is it running?
sudo systemctl start nginx      # start it
sudo systemctl restart nginx    # restart it
sudo systemctl enable nginx     # start automatically at boot

Watching the system

df -h                # disk space, human-readable
du -sh /var/log      # total size of a directory
top                  # live view of processes (q to quit)
ps aux | grep node   # find running node processes

Your First Shell Script

A shell script is just a file of commands the shell runs top to bottom. It's how you turn a repetitive chore into a single command.

#!/bin/bash
# The first line (the "shebang") tells the system to run this with bash.

echo "Hello, world!"

# Variables — no spaces around the =
name="Ray"
echo "Hello, $name!"

# A conditional
if [ "$name" = "Ray" ]; then
    echo "Welcome back, Ray."
else
    echo "Who goes there?"
fi

# A loop
for i in 1 2 3; do
    echo "Count: $i"
done

Make it executable, then run it:

chmod +x hello.sh    # give it execute permission
./hello.sh           # run it (the ./ means "in this directory")

A useful example: a timestamped backup

#!/bin/bash
# Back up a folder into a timestamped tar.gz archive.

source_dir="$HOME/documents"
backup_dir="$HOME/backups"
timestamp=$(date +%Y%m%d_%H%M%S)      # command substitution

mkdir -p "$backup_dir"
tar -czf "$backup_dir/backup_$timestamp.tar.gz" "$source_dir"

echo "Backup created: $backup_dir/backup_$timestamp.tar.gz"

The $(date ...) is command substitution: the shell runs date and drops its output right into the string. Quoting variables like "$source_dir" keeps paths with spaces from breaking.

$ ./backup.sh
Backup created: /home/username/backups/backup_20260731_142530.tar.gz

Command Cheat Sheet

Keep this within reach — these cover the vast majority of daily terminal work.

Practice & Quiz

my-app/
├── index.js
├── run.sh
└── src/
    └── utils.js

cd ~
mkdir -p my-app/src
cd my-app
touch index.js run.sh src/utils.js
chmod +x run.sh

# Verify
ls -R
# .:
# index.js  run.sh  src
# ./src:
# utils.js

grep -i "error" app.log | wc -l
# or, equivalently, grep's own counter:
grep -ic "error" app.log

Best Practices & Pitfalls

✅ Do

• Use Tab completion constantly — it's faster and prevents typos
• Run pwd and ls to orient yourself before any destructive command
• Quote paths that contain spaces: cd "My Folder"
• Run sudo apt update before installing packages
• Grant the least permission that works — 644 for files, 755 for scripts
• Read command --help before running anything unfamiliar

❌ Don't

• Run rm -rf on a path you haven't double-checked — there is no undo
• Paste commands from the internet without understanding them
• Reach for chmod 777 or sudo to "just make it work"
• Forget that Ubuntu is case-sensitive — App.js ≠ app.js
• Assume wildcards are harmless — preview rm *.log with ls *.log first

# Intended: delete temp files
rm temp *.log
# Oops — the stray space means "delete a file named temp
# AND every .log file." The shell expands wildcards BEFORE rm runs.

Summary

📚 Additional Resources

• Ubuntu — The Linux command line for beginners
• Ubuntu — Using the terminal
• Microsoft — Install WSL on Windows

🚀 What's Next?

You've reached the end of the Reference & Extras track. Everything backend in this bootcamp — Git, Node, npm, Docker, and your deploys — runs on the command line you just learned. Head back to the Course Home to keep building on this foundation.