How Do I Find Help in the Unix Manual?

After this lesson, you will be able to:

• Use man to read the manual page for any Unix command
• Navigate man pages (scroll, search with /, quit with q)
• Understand man page sections (1-8) and use man N command for specific sections
• Use --help flag and info as alternative help sources
• Search your command history with history, Ctrl+R, and !n

You’re Stuck. Now What?

You’re in the terminal, you know the command you need is chmod, but you can’t remember the flags. In CSCD 210, you would hover over a method in VS Code and read the tooltip, or open Javadoc in a browser. But there’s no tooltip here. No autocomplete popup. Just a blinking cursor.

Unix has had a solution for this since the 1970s: man pages (manual pages). They’re the built-in documentation system, available on every Unix machine, no internet required. And once you learn to read them, you’ll find they’re more reliable than most StackOverflow answers.

Reading the Manual (and Working Faster)

Four Types of Commands

Before we look up help, it helps to know that Unix has four types of commands:

1. Executable programs — compiled binaries in /usr/bin, /bin, etc. (e.g., ls, cp, gcc)
2. Shell builtins — commands built into bash itself (e.g., cd, echo, exit)
3. Shell functions — mini scripts defined in your environment
4. Aliases — custom shortcuts (e.g., ll for ls -la)

You can find out what type a command is with type:

type ls

Output: ls is aliased to 'ls --color=auto' — it’s an alias!

type cd

Output: cd is a shell builtin — built into bash.

type gcc

Output: gcc is /usr/bin/gcc — an executable program.

The which command finds executables in your PATH:

which gcc          # /usr/bin/gcc
which cd           # (no output — cd is a builtin, not in PATH)

Key Insight: which only finds external programs. type finds everything — builtins, aliases, functions, and executables. When you want to know “what IS this command?”, use type. When you want to know “where is the binary?”, use which.

Man Pages: The Built-In Manual

Every standard Unix command has a manual page. To read it:

man ls

You’re now in a pager — a scrollable document viewer. Navigate with:

Reading a Man Page

Every man page follows the same structure:

LS(1)                    User Commands                    LS(1)

NAME
       ls - list directory contents

SYNOPSIS
       ls [OPTION]... [FILE]...

DESCRIPTION
       List information about the FILEs (the current directory
       by default). Sort entries alphabetically...

OPTIONS
       -a, --all
              do not ignore entries starting with .
       -l     use a long listing format
       ...

EXAMPLES
       ...

SEE ALSO
       ...

The key sections:

• NAME — what it does (one line)
• SYNOPSIS — how to call it (brackets [] mean optional)
• DESCRIPTION — detailed explanation
• OPTIONS — all the flags and what they do
• EXAMPLES — usage examples (not all man pages have these)
• SEE ALSO — related commands

From Java: Javadoc is organized by class, with method signatures and descriptions. Man pages are organized by command, with synopses and option lists. The structure is different, but the skill is the same: reading technical reference documentation. Learning to read man pages is a professional skill that transfers everywhere.

Man Page Sections

The number in parentheses (like LS(1)) refers to the section:

Why does this matter? Some names exist in multiple sections:

man printf           # Section 1: the shell command
man 3 printf         # Section 3: the C library function

You’ll use man 3 extensively when writing C code — it’s the reference for printf, scanf, malloc, fopen, and every other C library function.

Searching for Commands

Don’t know the command name? Search by keyword:

man -k permission     # Find commands related to "permission"

This might show:

chmod (1)            - change file mode bits
chown (1)            - change file owner and group
stat (1)             - display file status

apropos does the same thing:

apropos directory     # Find commands related to "directory"

Quick Help: --help

Most commands support a --help flag for a brief usage summary:

ls --help

This is faster than man when you just need a quick reminder of a flag.

Command History: Stop Retyping

Every command you type is saved in your history. This is a massive time-saver:

history              # Show all previous commands (numbered)

Navigation shortcuts:

The Trick: Ctrl+R is the single most useful history shortcut. Press Ctrl+R, start typing part of a previous command, and it shows the most recent match. Press Ctrl+R again to cycle through older matches. Press Enter to run it, or arrow keys to edit it first.

Example workflow:

gcc -Wall -o myprogram myprogram.c     # Compile (long command)
./myprogram                             # Run
# Find a bug, edit the file...
Ctrl+R then type "gcc"                  # Instantly recalls the compile command

Tab Completion: Let the Shell Do the Typing

Press Tab to auto-complete file names, directory names, and command names:

cd ~/csc<Tab>          # Completes to cd ~/cscd240/
ls my<Tab>             # Completes to ls myprogram.c

If there are multiple matches, press Tab twice to see all possibilities:

ls my<Tab><Tab>
# myprogram.c  myprogram.h  myfile.txt

The Trick: If Tab doesn’t complete anything, either: (1) no file matches what you’ve typed (check for typos), or (2) the file doesn’t exist. Tab completion doubles as a quick existence check.

Essential Keyboard Shortcuts

These work in any bash session:

Common Pitfall: Ctrl+C and Ctrl+D do different things. Ctrl+C cancels whatever is currently running — use it when a program hangs or you want to abort. Ctrl+D sends an end-of-file signal — if the line is empty, it closes your terminal. Don’t confuse them.

The echo Command

echo prints text to the screen. Simple, but useful:

echo "Hello, world!"           # Print a message
echo $HOME                      # Print the value of HOME variable
echo $?                         # Print exit status of last command

The exit status ($?) is important: 0 means success, any other number means error. You’ll use this in scripts and when debugging.

You’re No Longer Lost

You now have three superpowers: man for looking up any command, history and Ctrl+R for recalling previous commands, and Tab for auto-completing paths. These aren’t just nice-to-have — they’re how experienced Unix users work so fast. They’re not memorizing hundreds of flags; they’re looking them up efficiently.

Next up: file permissions. You’ve been creating and moving files, but who else can see them? And what does that rwxr-xr-x string mean in the ls -l output? That’s Lesson 1.4.

Big Picture: Man pages are your primary reference for C library functions. When you start writing C code in Week 3, man 3 printf and man 3 scanf will be commands you type multiple times per lab session. The skill you’re building now — reading technical documentation — is the same skill professional developers use every day.