Using info, pinfo, and --help for LFCS Certification

Welcome to Part 13 of the LFCS Certification - Phase 1 series! You've mastered man pages. Now let's explore three additional documentation systems that complement man pages: info pages, pinfo, and the --help option.

What Are info Pages?

info pages are GNU's hypertext documentation system - think of them as Wikipedia for Linux commands, with clickable links between topics.

info vs man: Key Differences

Using info Command

Basic info Syntax

# View info page for a command
info command_name

# Examples:
info ls
info grep
info tar
info bash

Your First info Page

info ls

What you see:

File: coreutils.info,  Node: ls invocation,  Next: dir invocation

10.1 'ls': List directory contents
===================================

The 'ls' program lists information about files (of any type, including
directories).  Options and file arguments can be intermixed arbitrarily,
as usual.

   For non-option command-line arguments that are directories, by
default 'ls' lists the contents of directories, not recursively, and
omitting files with names beginning with '.'.  For other non-option
arguments, by default 'ls' lists just the file name.  If no non-option
argument is specified, 'ls' operates on the current directory.

Understanding info Page Structure

The top line shows:

• File: Which info file you're reading (coreutils.info)
• Node: Current topic/section (ls invocation)
• Next: Next topic in sequence
• Prev: Previous topic (if exists)
• Up: Parent topic

Essential info Navigation Keys

Advanced info Syntax

Accessing Specific Nodes

# Access specific node within an info file
info '(coreutils) ls invocation'

# Format: info '(file) node name'

Real examples:

info '(coreutils) ls invocation'    # ls command details
info '(coreutils) cp invocation'    # cp command details
info '(bash) Shell Parameters'      # Bash parameters
info '(tar) Synopsis'               # tar synopsis

Why This Syntax Matters

Problem: Running info ls might show the main coreutils page, requiring navigation.

Solution: Jump directly to the section you need!

# Instead of:
info coreutils
# Then navigate to ls section...

# Do this:
info '(coreutils) ls invocation'
# Jump directly!

Introducing pinfo

pinfo is an enhanced info browser with a more intuitive interface.

Installing pinfo

# RHEL/CentOS/Rocky/Alma
sudo dnf install pinfo

# Debian/Ubuntu
sudo apt install pinfo

pinfo vs info

Using pinfo

# Same syntax as info
pinfo ls
pinfo grep
pinfo tar

# Also supports direct node access
pinfo '(coreutils) ls invocation'

Navigation in pinfo:

• Arrow keys: Move cursor
• Enter: Follow highlighted link
• Up arrow: Move to links
• Escape: Go back
• Q: Quit

Using --help Option

The --help option provides quick command reference without leaving your terminal.

Basic --help Usage

# Show help for any command
command --help

# Examples:
ls --help
cp --help
tar --help
grep --help

--help Output Format

ls --help

Output:

Usage: ls [OPTION]... [FILE]...
List information about the FILEs (the current directory by default).

Mandatory arguments to long options are mandatory for short options too.
  -a, --all                  do not ignore entries starting with .
  -A, --almost-all           do not list implied . and ..
  -b, --escape               print C-style escapes for nongraphic characters
  -l                         use a long listing format
  ...

Exit status:
 0  if OK,
 1  if minor problems (e.g., cannot access subdirectory),
 2  if serious trouble (e.g., cannot access command-line argument).

When to Use --help

Use --help when:

• ✅ You need a quick reminder of options
• ✅ You want to check if an option exists
• ✅ You're already in the terminal working
• ✅ You need quick syntax reference
• ✅ Time is critical (faster than man)

Use man when:

• ❌ You need detailed explanations
• ❌ You want examples
• ❌ You need to understand behavior
• ❌ You're learning a new command

Comparing Documentation Methods

Example: ls Command

man ls:

man ls

• Comprehensive reference
• Detailed option explanations
• Exit status codes
• 200+ lines of documentation

info ls:

info '(coreutils) ls invocation'

• Tutorial-style explanations
• Hyperlinked related topics
• Contextual information
• 300+ lines with examples

ls --help:

ls --help

• Quick option list
• Brief descriptions
• Exit status summary
• 80-100 lines of concise info

Which to Use When?

🧪 Practice Labs

Time to master all three documentation systems!

Lab 1: Basic info Navigation (Beginner)

Tasks:

1. Open info page for ls
2. Practice navigation keys (n, p, u, t)
3. Follow a hyperlink with Tab and Enter
4. Use 'l' to go back
5. Search for "recursive" with 's'

# Task 1: Open ls info page
info ls

# Task 2: Practice navigation
# Press n    (next node)
# Press p    (previous node)
# Press u    (up to parent)
# Press t    (top/main menu)

# Task 3 & 4: Follow hyperlinks
# Press Tab repeatedly to cycle through links
# When on a link you want, press Enter
# Press l to go back

# Task 5: Search
# Press s
# Type: recursive
# Press Enter
# Finds mentions of "recursive"

# Exit
Press q

Lab 2: Direct Node Access (Beginner)

Tasks:

1. Access ls invocation directly
2. Access cp invocation directly
3. Access tar synopsis directly
4. Compare with regular info command
5. Document the time savings

# Task 1: Direct ls access
info '(coreutils) ls invocation'
# Jumps directly to ls documentation

Press q

# Task 2: Direct cp access
info '(coreutils) cp invocation'
# Jumps directly to cp documentation

Press q

# Task 3: Direct tar access
info '(tar) Synopsis'
# Or:
info '(tar) Tutorial'

Press q

# Task 4: Compare with regular command
time info ls
# Navigate to find what you need...
# Press q

time info '(coreutils) ls invocation'
# Already there!
# Press q

# Task 5: Document savings
cat << 'EOF'
Time Comparison:

Regular info command:
1. Launch info
2. Navigate main menu
3. Find section
4. Read content
Estimated: 30-60 seconds

Direct node access:
1. Launch directly to section
2. Read content
Estimated: 5 seconds

Time saved: 25-55 seconds per lookup!

Direct access syntax:
info '(file) node name'
EOF

Lab 3: Installing and Using pinfo (Beginner)

Tasks:

1. Install pinfo
2. Compare info vs pinfo interface
3. Navigate with arrow keys
4. Notice highlighted links
5. Test fallback to man pages

# Task 1: Install pinfo
# RHEL/CentOS
sudo dnf install pinfo

# Debian/Ubuntu
sudo apt install pinfo

# Task 2: Compare interfaces
info ls
# Note: Plain text, links hard to see
Press q

pinfo ls
# Note: Colored, links highlighted
Press q

# Task 3: Navigate with arrow keys
pinfo ls
# Use arrow keys to move cursor
# Much more intuitive than info

# Task 4: Notice links
# Links are clearly highlighted in color
# Cursor can select them directly

# Task 5: Test fallback
pinfo some_command_without_info_page
# pinfo automatically shows man page instead!
# Falls back gracefully

Press q

Lab 4: Mastering --help (Beginner)

Tasks:

1. Compare --help output for 5 commands
2. Find specific option using grep
3. Pipe --help to less for long output
4. Save --help output to file
5. Create personal --help quick reference

# Task 1: Compare --help output
ls --help
cp --help
mv --help
rm --help
find --help

# Task 2: Find specific option
ls --help | grep -i recursive
# Shows: -R, --recursive

cp --help | grep -i preserve
# Shows: -p, --preserve

tar --help | grep -i compress
# Shows: -z, --gzip

# Task 3: Pipe to less
find --help | less
# Easier to read long help output

# Task 4: Save to file
ls --help > ~/ls-help.txt
cat ~/ls-help.txt

# Task 5: Create reference
cat << 'EOF' > ~/help-quick-reference.txt
Quick --help Reference

Common Patterns:
- Short option: -l
- Long option: --long
- Option with value: -o value or --option=value

Finding Options:
command --help | grep keyword

Example: Find recursive option
ls --help | grep recursive

Saving help:
command --help > file.txt

Paging long help:
command --help | less

When to use:
- Quick option check
- Verify option exists
- Copy exact syntax
- Script integration
EOF

cat ~/help-quick-reference.txt

Lab 5: Comparing Documentation (Intermediate)

Tasks:

1. Compare man, info, and --help for tar
2. Note differences in detail level
3. Find information in each source
4. Determine best use case for each
5. Create decision flowchart

# Task 1-2: Compare all three
tar --help
# Shows: Basic syntax, common options
# Length: ~100 lines

man tar
# Shows: Comprehensive reference
# Length: 500+ lines
Press q

info tar
# Shows: Tutorial with examples, hyperlinked
# Length: 1000+ lines (across nodes)
Press q

# Task 3: Find how to create tar.gz
# In --help:
tar --help | grep gzip
# Quick answer: -z

# In man:
man tar
/gzip
# Detailed explanation
Press q

# In info:
info tar
# Navigate to compression section
# Tutorial explanation with examples
Press q

# Task 4-5: Create flowchart
cat << 'EOF'
Documentation Decision Flowchart:

START: Need help with command?
  ↓
  Do you know the command name?
    No → use: man -k (apropos)
    Yes → Continue
      ↓
      How much detail do you need?
        ↓
        Quick option check → --help
          - Fastest
          - Lists options
          - Brief descriptions

        Detailed reference → man
          - Comprehensive
          - Searchable
          - Config files (section 5)

        Learning/Tutorial → info
          - Extensive examples
          - Hyperlinked
          - GNU tools especially

Special cases:
- Config file format? → man 5 filename
- GNU tool deep dive? → info tool
- Quick syntax? → --help
- Learning new tool? → info, then man

Efficiency tips:
- Start with --help
- If not enough, try man
- For GNU tools, check info
- Use pinfo if available (better than info)
EOF

Due to length constraints, I'll summarize Labs 6-20:

Labs 6-20 (Summary)

Lab 6: info hyperlink exploration Lab 7: Coreutils info deep dive Lab 8: Using info for bash scripting Lab 9: Creating --help cheat sheets Lab 10: Speed challenge - documentation race Lab 11: GNU vs non-GNU tool documentation Lab 12: info page structure analysis Lab 13: pinfo customization Lab 14: Parsing --help output in scripts Lab 15: Building personal documentation library Lab 16: Advanced info searching Lab 17: Comparing info nodes Lab 18: --help output formatting Lab 19: Documentation troubleshooting Lab 20: Final mastery challenge

# Lab 6: info hyperlink exploration
info '(coreutils)'
# Tab through all available links
# Map out the structure

# Lab 7: Coreutils deep dive
info coreutils
# Explore: File operations, Shell utilities, Text utilities

# Lab 8: Bash scripting with info
info bash
info '(bash) Shell Parameters'
info '(bash) Conditional Constructs'

# Lab 9: Create --help cheat sheet
for cmd in ls cp mv rm mkdir; do
    echo "=== $cmd ===" >> ~/help-cheat.txt
    $cmd --help | head -3 >> ~/help-cheat.txt
done

# Lab 10: Speed challenge
# Find tar compression option in under 30 seconds using all 3 methods

# Labs 11-20 focus on:
# - Advanced navigation techniques
# - Integration with scripts
# - Custom documentation strategies
# - Real-world problem solving

📚 Best Practices

Documentation Strategy

1. Start with --help - Fastest for quick checks
2. Use man for reference - Most reliable, always available
3. Use info for learning - Best for understanding concepts
4. Prefer pinfo over info - If available, more user-friendly
5. Know when to escalate - Don't waste time in wrong resource

For LFCS Exam

1. --help is fastest during time-critical tasks
2. man pages are primary - Always available, comprehensive
3. info pages optional - Good for GNU tools if time allows
4. Practice offline - Exam environment may limit resources
5. Build muscle memory - Know which tool for which task

Workflow Integration

# Add to ~/.bashrc
# Quick documentation access
doc() {
    echo "Trying --help first..."
    $1 --help 2>/dev/null || {
        echo "No --help available, trying man..."
        man $1 2>/dev/null || {
            echo "No man page, trying info..."
            info $1
        }
    }
}

# Usage:
doc ls    # Tries --help, falls back to man, then info

🚨 Common Pitfalls

Pitfall 1: Using Wrong Tool

# WRONG - info for config file format
info fstab
# info doesn't have this!

# CORRECT - man section 5
man 5 fstab

Pitfall 2: Not Trying --help First

# INEFFICIENT:
man tar
# Scroll through 500 lines...

# EFFICIENT:
tar --help | grep compress
# Answer in 2 seconds

Pitfall 3: Forgetting Direct Node Access

# SLOW:
info coreutils
# Navigate to ls section...

# FAST:
info '(coreutils) ls invocation'

📝 Quick Reference

Command Summary

# info commands
info command                         # Open info page
info '(file) node'                   # Jump to specific node
info coreutils                       # All coreutils docs
pinfo command                        # Better info interface

# --help option
command --help                       # Quick reference
command --help | grep keyword        # Find specific option
command --help | less                # Page through help

Navigation Keys

# info/pinfo navigation
n       # Next node
p       # Previous node
u       # Up to parent
Tab     # Next hyperlink
Enter   # Follow link
l       # Go back (last)
t       # Top (main menu)
s       # Search
q       # Quit

Decision Matrix

Need quick option? → --help
Need detailed reference? → man
Learning new concept? → info
Config file format? → man 5
GNU tool tutorial? → info

🎯 Key Takeaways

1. Three documentation systems - Each serves different purpose
2. --help is fastest - For quick option lookups
3. man is comprehensive - Your primary reference (always available)
4. info is for learning - Best for understanding concepts
5. pinfo is better - Use it instead of info if available
6. Start with --help - Escalate to man, then info
7. Direct node access - Use info '(file) node' to save time
8. Know the right tool - Don't waste time in wrong resource

🚀 What's Next?

You've mastered info, pinfo, and --help! In the next post, we'll explore additional documentation resources hidden in your Linux system.

Coming up in Part 14: Exploring /usr/share/doc and tldr

• Purpose of /usr/share/doc
• Finding package documentation
• README files, examples, changelogs
• Installing and using tldr (simplified man pages)
• tldr vs man: When to use each
• Creating your own documentation library
• And much more!