⌨️ Terminal / Command Line Introduction

Why the Terminal Matters

A terminal (or command-line interface) is a text-based way to tell your computer exactly what to do. Graphical interfaces are friendly, but they hide power behind menus and only do what a designer anticipated. The terminal does anything the system can do — and it does it fast, repeatably, and scriptably.

💡 Analogy: A GUI is a restaurant menu — convenient, but you can only order what's printed. The terminal is walking into the kitchen and cooking whatever you like. Slightly scarier, infinitely more capable.

Three concrete reasons developers live in the terminal:

• Speed: "find every JavaScript file changed this week that mentions fetch" is one line instead of a dozen clicks.
• Automation: anything you can type, you can save as a script and run again forever.
• It's how the tools work: Git, npm, Docker, deployment pipelines, and remote servers are all driven from the command line.

How the Shell Works

The program that reads your typed commands is called a shell. On Linux and modern macOS it's usually Bash or Zsh; on Windows it's PowerShell. The loop is always the same: it prints a prompt, you type a command, it runs the command, prints any output, and prompts again.

A command has up to three parts: the command itself, optional options (flags, usually starting with -), and optional arguments (what to act on):

ls   -la   /home/ray
# │    │      │
# │    │      └─ argument: which directory to list
# │    └──────── options: -l long format, -a include hidden files
# └───────────── command: "list directory contents"

Navigating the Filesystem

Everything on a Unix-like system lives in a single tree that starts at the root (/). You're always "standing" in one directory — the working directory — and you move around with a few commands.

pwd            # print working directory — "where am I?"
ls             # list what's in this directory
ls -la         # long listing, including hidden dot-files
cd projects    # change into the 'projects' subfolder
cd ..          # go up one level to the parent
cd ~           # jump to your home directory
cd -           # toggle back to the previous directory

The Linux filesystem follows a standard layout. You rarely touch most of it, but it helps to recognize the map:

Working With Files

Creating, copying, moving, and deleting files are the bread-and-butter operations. Here are the ones you'll use constantly:

# Create
touch notes.txt                 # create an empty file
mkdir app                       # create a directory
mkdir -p app/src/components      # create nested dirs in one shot

# Inspect
cat notes.txt                    # print a file's whole contents
less server.log                  # scroll a big file (q to quit)
head -n 20 data.csv              # first 20 lines
tail -n 20 data.csv              # last 20 lines
tail -f server.log               # follow a log live as it grows

# Copy / move / rename
cp notes.txt notes.bak           # copy
cp -r app app-backup             # copy a directory recursively
mv notes.txt docs/notes.txt      # move
mv old-name.txt new-name.txt     # rename (same command)

# Delete
rm notes.bak                     # remove a file
rm -r app-backup                 # remove a directory and its contents

Commands Across Operating Systems

The classic Unix commands (ls, cat, cp…) work identically on macOS and Linux. Windows PowerShell uses different native command names but provides aliases so many Unix commands still work:

# Run in an elevated PowerShell, then reboot
wsl --install

Pipes & Redirection

Here's where the terminal becomes genuinely powerful. The Unix philosophy is "small tools that do one thing well," combined with two operators that connect them:

• Pipe | — send the output of one command straight into the next as input.
• Redirect > / >> — send output into a file (overwrite / append) instead of the screen.

# Redirect output into files
echo "node_modules/" > .gitignore     # create/overwrite
echo ".venv/" >> .gitignore            # append a second line

# Pipe: chain small tools into a pipeline
history | grep git                     # find past commands mentioning 'git'
ls -la | wc -l                         # count how many items are here

# A real one-liner: top 5 most common HTTP status codes in a log
cat access.log | cut -d ' ' -f 9 | sort | uniq -c | sort -nr | head -5

Read that last line left to right as an assembly line: cat pours out the log → cut grabs the status-code column → sort groups identical codes → uniq -c counts each group → sort -nr ranks them → head -5 keeps the top five. Each tool is simple; together they answer a real question in one line.

Speed: History & Shortcuts

Two habits separate slow terminal users from fast ones: never retype, and never mash the arrow keys.

Reuse what you already typed

• ↑ / ↓ — walk through previous commands.
• Ctrl + R — reverse-search history; start typing and it finds the last matching command.
• Tab — autocomplete a command or file name; press twice to see all options.
• !! — repeat the last command (handy as sudo !! after a permission error).

Move the cursor without arrows

Make shortcuts of your own: aliases

An alias is a nickname for a longer command. Add these to ~/.bashrc (or ~/.zshrc) and reload with source ~/.bashrc:

# ~/.bashrc
alias ll='ls -alF'
alias gs='git status'
alias gp='git push'
alias ..='cd ..'

Hands-on Exercise

mkdir -p my-site/{css,js,images}
touch my-site/index.html my-site/css/style.css my-site/js/app.js
find my-site -type f | sort

# Build a tiny log to work with
printf 'INFO ok\nERROR disk\nINFO ok\nERROR net\nWARN slow\nERROR net\n' > app.log

# Question: how many ERROR lines are there?
grep -c ERROR app.log

# Bonus: which error is most common?
grep ERROR app.log | sort | uniq -c | sort -nr

Summary & Quiz

📚 Further Reading

• Ubuntu — Command Line for Beginners
• explainshell — paste any command to see what each part does
• The Art of Command Line
• Linux Journey — interactive lessons

🚀 What's Next?

You can now move around and manipulate files from the terminal. Next we'll set up the editor where you'll spend most of your time — installing and configuring VS Code so it works hand-in-glove with the command line you just learned.