Module 01: Shell Basics and Unix Philosophy

🎯 Goal: Use the Linux terminal as a tool you can reason about rather than a list of commands to memorize.

By the end of this module, you should be able to distinguish a terminal from a shell, read a Bash prompt, understand a command's parts, find help for unfamiliar commands, use completion and history, and explain why small Linux tools compose well.

Why this matters

You will use the terminal to inspect logs, start development servers, connect to remote machines, run Git and Docker commands, and debug deployments. The syntax matters, but the more useful skill is understanding what the shell is doing with the text you type.

1. Terminal, shell, command, and kernel

flowchart TD
    T["Terminal emulator"] --> S["Bash shell"]
    S --> C["Command or shell builtin"]
    C --> K["Linux kernel"]
    K --> C
    C --> S
    S --> T

2. Read the prompt before acting

A typical Bash prompt looks like this:

asha@laptop:~/projects$

The root account commonly ends with #. Treat that as a reminder to slow down: a root command can change any part of the system.

3. Commands have a predictable shape

Most command lines follow this pattern:

command   options   arguments
git       status    --short

• The command chooses a program or shell feature.
• An option changes behavior, often starting with - or --.
• An argument is the item the command acts on.

For example:

ls -la ~/projects

ls lists; -l asks for a detailed view; -a includes dotfiles; ~/projects is the target directory.

4. Some commands are built into Bash

Not every command is a file on disk. cd, alias, and history are shell builtins; they must change or inspect the current shell, so launching a separate program would not work.

Use these commands to identify what you are invoking:

type cd
type ls
command -v git

type tells you whether a name is a builtin, alias, function, or executable. command -v gives a concise lookup that is useful in scripts.

5. Documentation is part of the workflow

You should not memorize every option. Use the documentation closest to the command:

Inside man, press q to quit and /word to search. A manual page has not frozen the terminal; it has opened a pager waiting for navigation.

6. Completion and history reduce mistakes

Press Tab to ask Bash to complete a command, path, or option. Press it twice when there is more than one possible completion.

Useful history controls:

clear changes what you see; it does not erase your command history.

flowchart LR
    I["Start typing"] --> T["Tab completion\nreduce spelling errors"]
    T --> R["Run command"]
    R --> H["History records command"]
    H --> S["Ctrl+R finds it later"]

7. Errors are useful evidence

Read an error literally before adding sudo, changing a path, or searching online.

8. The Unix philosophy: compose focused tools

Linux tools often do one task well and pass text to another tool. You will learn pipes in module 07, but the idea matters now: a command's output can become another command's input.

flowchart LR
    A["One small tool\nproduces text"] --> B["Another tool\nfilters or transforms"] --> C["Useful result"]

This model is why commands such as ls, grep, sort, curl, and journalctl work well together. It is not an absolute rule—some data is binary or structured—but it is a powerful default for command-line work.

Guided lab: become your own documentation engine

Work in your Ubuntu terminal.

1. Identify your environment

whoami
hostname
pwd
echo "$SHELL"

Expected: you can name the current user, machine, directory, and shell path.

2. Inspect command types

type cd
type pwd
type ls
command -v python3

Expected: cd is a Bash builtin; ls and python3 are normally executable programs; pwd may be either a builtin or executable depending on Bash behavior.

3. Discover one unfamiliar option

date --help
man date

Use /format inside the manual page, then press q. Do not try to memorize output formats; prove that you can find them.

4. Use completion deliberately

Type cd ~/pro and press Tab. If there are several matches, press Tab again to view them. Finish the path without typing the rest manually.

5. Use history safely

echo "shell practice"
history | tail -n 5

Use Up arrow to bring back the echo command, change its text, and run it. Then press Ctrl+R, type part of shell practice, and locate the earlier command.

6. Read an error

not-a-real-command

Expected: command not found. Use type not-a-real-command to confirm that Bash cannot resolve the name.

Independent challenge

You are given this request: “Find the current directory, list everything in it including hidden names, and learn how ls sorts its output.”

Write the commands you would use, identify which command feature solves each part, and use built-in documentation to find one sorting option you did not already know.

Further reading

• GNU Bash Reference Manual
• GNU Coreutils: Common options
• man7.org: intro(1)

Next

Continue to 02 · Filesystem Navigation. The shell needs paths and files to operate on; the next module builds that vocabulary.