LFCS Phase 1 Part 24: Understanding Absolute vs Relative Paths

Imagine you're trying to explain to someone how to get to a cafe. You could say "Go to 123 Main Street" (absolute location) or "Go two blocks north from where you are" (relative location). Linux paths work exactly the same way—and understanding this distinction is absolutely fundamental to navigating the filesystem efficiently.

Paths are how you specify the location of files and directories in Linux. Every command that works with files—cd, ls, cp, mv, mkdir—uses paths. Mastering paths means mastering Linux navigation, and it's a critical skill for the LFCS exam and daily system administration.

What is a Path?

A path is a string that specifies the location of a file or directory in the Linux filesystem hierarchy.

Think of it like an address:

• Postal address: "123 Main Street, City, State, ZIP"
• Linux path: /home/username/documents/file.txt

Both tell you exactly where something is located.

Path Components

A path consists of:

1. Directory names separated by forward slashes (/)
2. Filename (if pointing to a file)
3. Optional special symbols (., .., ~)

Example breakdown:

/home/centos9/projects/website/index.html
│ │    │       │        │       └─ Filename
│ │    │       │        └───────── Directory
│ │    │       └────────────────── Directory
│ │    └────────────────────────── Directory
│ └─────────────────────────────── Directory
└───────────────────────────────── Root (starting point)

Absolute Paths: Starting from Root

An absolute path always starts from the root directory / and provides the complete location regardless of your current position.

Characteristics of Absolute Paths

Key features:

• Always starts with / (forward slash)
• Complete path from root to target
• Works from anywhere in the filesystem
• Never ambiguous—always refers to the same location

Example Absolute Paths

/etc/passwd                    # Password file
/home/centos9/documents       # User's documents directory
/var/log/messages             # System log file
/usr/bin/python3              # Python executable

Using Absolute Paths

# View file using absolute path (works from anywhere)
cat /etc/hostname

# Navigate to directory using absolute path
cd /var/log

# Copy file using absolute path
cp /etc/hosts /tmp/

# Create directory with absolute path
mkdir /tmp/test_directory

# From /home/centos9
cd /etc

# From /tmp
cd /etc

# From /var/log
cd /etc

# All three work identically—absolute paths are location-independent!

Relative Paths: Starting from Current Location

A relative path specifies a location relative to your current working directory. It does NOT start with /.

Characteristics of Relative Paths

Key features:

• Does NOT start with /
• Relative to current working directory (pwd)
• Changes meaning based on where you are
• Often shorter and more convenient

Example: How Relative Paths Work

Setup:

# Current location
pwd
# Output: /home/centos9

Now relative paths:

documents          # Means: /home/centos9/documents
projects/website   # Means: /home/centos9/projects/website
../centos8         # Means: /home/centos8 (parent, then centos8)
./file.txt         # Means: /home/centos9/file.txt (current dir)

If you change location, meanings change:

# Move to different directory
cd /tmp
pwd
# Output: /tmp

# Now the SAME relative paths mean different things:
documents          # Means: /tmp/documents
projects/website   # Means: /tmp/projects/website
../centos8         # Means: /centos8 (parent of /tmp, then centos8)

Real Example from Source Material

# Navigate to /tmp
cd /tmp
pwd

Output:

/tmp

# Create directory and copy file (relative paths)
mkdir data
cp /etc/hosts .             # Copy to current directory (.)
cp /etc/passwd data         # Copy to data subdirectory

# Navigate into data
cd data
pwd

Output:

/tmp/data

# Copy to parent directory using ..
cp passwd ..
ls ..

Files are now in /tmp (parent directory).

Special Path Symbols

Linux provides special symbols for common path operations.

The Dot (.) - Current Directory

The . (single dot) represents the current directory.

Examples:

pwd
# Output: /home/centos9

# These are equivalent:
ls .
ls

# Copy file to current directory
cp /etc/hostname .
# Same as: cp /etc/hostname /home/centos9/

# Execute script in current directory
./script.sh
# The ./ explicitly means "run from current directory"

Why use . when it seems redundant?

1. Explicit destination for cp/mv:

   cp /etc/hosts .    # Clear: copy TO current directory
   

   Copy

2. Execute local scripts:

   ./myscript.sh      # Run script from current directory
   # Not just: myscript.sh (which searches $PATH)
   

   Copy

3. Find command:

   find . -name "*.txt"    # Search starting from current directory
   

   Copy

The Dot-Dot (..) - Parent Directory

The .. (double dot) represents the parent directory (one level up).

Examples:

pwd
# Output: /home/centos9/projects/website

# Go up one level
cd ..
pwd
# Output: /home/centos9/projects

# Go up two levels
cd ../..
pwd
# Output: /home/centos9

Using .. with file operations:

# Current: /tmp/data
pwd
# Output: /tmp/data

# Copy file to parent directory
cp file.txt ..
# File is now in /tmp/

# List parent directory
ls ..

# Copy from parent to current
cp ../hosts .

Chaining .. for multiple levels:

# Current: /home/centos9/projects/website/assets/images
pwd
# Output: /home/centos9/projects/website/assets/images

# Go up 3 levels
cd ../../..
pwd
# Output: /home/centos9/projects

The Tilde (~) - Home Directory

The ~ (tilde) represents your home directory (/home/username).

Examples:

# Navigate to home from anywhere
cd ~
pwd
# Output: /home/centos9

# These are equivalent:
cd ~
cd
cd $HOME
cd /home/centos9

Using ~ in paths:

# Access file in home directory
cat ~/documents/notes.txt
# Same as: cat /home/centos9/documents/notes.txt

# Copy to home directory
cp /etc/hosts ~/

# Create directory in home
mkdir ~/new_project

# Use ~ with other users (if you know their username)
ls ~otheruser/
# Shows: /home/otheruser/

Combining ~ with subdirectories:

# All of these work:
~/documents
~/projects/website
~/.bashrc         # Hidden file in home
~/.config/        # Hidden directory in home

Absolute vs Relative: Detailed Comparison

When to Use Absolute Paths

✅ Use absolute paths when:

• Writing scripts that run from different locations
• Referring to system files (/etc, /var, /usr)
• Need unambiguous reference
• Working with cron jobs or services
• Sharing commands with others

Example:

# Script that works from anywhere
#!/bin/bash
cp /etc/hostname /var/log/hostname.backup

When to Use Relative Paths

✅ Use relative paths when:

• Navigating nearby directories
• Working within a project structure
• Want shorter commands
• Project is portable/relocatable
• Quick interactive work

Example:

# Within a project
cd ~/project
cd src/components      # Relative - shorter
cp utils.js ../lib/    # Relative - convenient

Real-World Path Navigation Examples

Example 1: Navigating a Project Structure

/home/centos9/project/
├── src/
│   ├── components/
│   ├── utils/
│   └── main.js
├── tests/
├── docs/
└── README.md

Starting from: /home/centos9/project/src/components

# Navigate to utils (sibling directory)
cd ../utils
# Or absolute:
cd /home/centos9/project/src/utils

# Navigate to tests (uncle directory)
cd ../../tests
# Or absolute:
cd /home/centos9/project/tests

# Navigate to project root
cd ../..
# Or:
cd ~/project

Example 2: Copying Files Between Directories

Current location: /tmp/data

pwd
# Output: /tmp/data

# Copy file to parent directory
cp passwd ..

# Verify
ls ..
# Shows: data/ passwd ...

Absolute equivalent:

cp /tmp/data/passwd /tmp/

Example 3: Complex Navigation

Starting from: /var/log/httpd

# Goal: Get to /var/www/html

# Relative path:
cd ../../www/html

# Breakdown:
# ..     -> /var/log
# ../..  -> /var
# ../../www -> /var/www
# ../../www/html -> /var/www/html

# Absolute path (clearer):
cd /var/www/html

Common Path Patterns and Shortcuts

Back and Forth Navigation

# Current directory
pwd
# Output: /home/centos9

# Go somewhere
cd /var/log

# Go back to previous directory
cd -
pwd
# Output: /home/centos9

# Toggle between two directories
cd /etc      # Now in /etc
cd -         # Back to /home/centos9
cd -         # Back to /etc
cd -         # Back to /home/centos9

The cd - is incredibly useful for switching between two locations!

Home Directory Shortcuts

# All go to home directory:
cd
cd ~
cd $HOME
cd /home/username

# Quick navigation within home:
cd ~/documents
cd ~/projects/website
cd ~/.config

Combining Symbols

# Current location: /home/centos9/project/src

# Copy from parent's sibling
cp ../../docs/README.md .

# Create directory in home from anywhere
mkdir ~/new_folder

# Copy to home with relative source
cp ./file.txt ~/backups/

Path Resolution: How Linux Finds Files

Understanding how Linux resolves paths helps avoid errors.

Resolution Process

Absolute path:

1. Start at root /
2. Follow each directory in the path
3. Return the final location

Relative path:

1. Get current working directory (pwd)
2. Start from that location
3. Follow each directory in the path
4. Return the final location

Example Resolution

Current directory: /home/centos9

Resolve: documents/notes.txt

Steps:

1. Current dir: /home/centos9
2. Add documents: /home/centos9/documents
3. Add notes.txt: /home/centos9/documents/notes.txt

Resolve: ../centos8/file.txt

Steps:

1. Current dir: /home/centos9
2. .. means parent: /home
3. Add centos8: /home/centos8
4. Add file.txt: /home/centos8/file.txt

Common Path Errors and Solutions

Error 1: Forgetting Current Location

Problem:

# Think you're in /home/centos9
# Actually in /tmp

mkdir project
# Creates /tmp/project instead of /home/centos9/project!

Solution:

# Always check where you are
pwd

# Or use absolute paths
mkdir /home/centos9/project

# Or use ~
mkdir ~/project

Error 2: Confusing . and ..

Problem:

cp file.txt .    # Copies to current directory (useless!)

Solution:

# Copy to parent
cp file.txt ..

# Copy to specific location
cp file.txt ../backups/

Error 3: Missing Leading Slash

Problem:

# Wanted: /etc/hosts (absolute)
# Typed: etc/hosts (relative!)

cat etc/hosts
# Error: No such file or directory (looking for ./etc/hosts)

Solution:

# Absolute path - add leading /
cat /etc/hosts

Error 4: Too Many ../..

Problem:

# Complex: ../../../../somewhere/else
# Easy to miscount levels

Solution:

# Use absolute path when too complex
cd /somewhere/else

# Or navigate in steps:
cd ~           # Home first
cd /var        # Then absolute

Paths in Scripts vs Interactive Use

Interactive Use (Terminal)

Prefer relative paths:

• Faster to type
• Context is visible
• Can use shortcuts

# Interactive examples
cd src
cp ../README.md .
ls ../../docs

Scripts and Automation

Prefer absolute paths:

• Works regardless of execution location
• No ambiguity
• Easier to debug

#!/bin/bash
# Script example

# Bad (relative - depends on where script runs from)
cp config.txt backups/

# Good (absolute - always works)
cp /etc/myapp/config.txt /var/backups/myapp/

# Good (using $HOME for user-specific paths)
cp "$HOME/.bashrc" "$HOME/backups/"

🧪 Practice Labs

Time for hands-on practice! These 20 labs build your path navigation mastery.

cd ~
mkdir -p path-practice/{project/{src,tests,docs},backups,downloads}
cd path-practice

Lab 1: Identifying Path Types (Beginner)

Task: Identify whether each path is absolute or relative:

• /etc/passwd
• documents/file.txt
• ~/projects
• ../parent
• /home/user/file.txt

Lab 2: Using pwd to Find Current Location (Beginner)

Task: Navigate to different directories and use pwd to see your absolute path.

# Start at home
cd ~
pwd
# Output: /home/centos9 (or your username)

# Navigate to /tmp
cd /tmp
pwd
# Output: /tmp

# Navigate to /etc
cd /etc
pwd
# Output: /etc

# Navigate to /var/log
cd /var/log
pwd
# Output: /var/log

Lab 3: Navigating with Absolute Paths (Beginner)

Task: Use absolute paths to navigate to /etc, then /var/log, then back to your home directory.

# Navigate to /etc
cd /etc
pwd
# Output: /etc

# Navigate to /var/log
cd /var/log
pwd
# Output: /var/log

# Navigate to home (multiple ways)
cd /home/centos9    # Absolute
# or
cd ~                # Home shortcut
# or
cd                  # Default to home
# or
cd $HOME            # Environment variable

pwd
# Output: /home/centos9

Lab 4: Navigating with Relative Paths (Beginner)

Task: From ~/path-practice, navigate to project using a relative path.

# Ensure you're in the right place
cd ~/path-practice
pwd
# Output: /home/centos9/path-practice

# Navigate to project (relative)
cd project
pwd
# Output: /home/centos9/path-practice/project

# Navigate to src (relative from project)
cd src
pwd
# Output: /home/centos9/path-practice/project/src

Lab 5: Using the Dot (.) Symbol (Beginner)

Task: Copy /etc/hostname to your current directory using the . symbol.

# Navigate somewhere
cd ~/path-practice

# Copy using .
cp /etc/hostname .

# Verify
ls -l hostname

# Confirm it's in current directory
pwd
# Output: /home/centos9/path-practice

ls hostname
# Output: hostname

Lab 6: Using the Dot-Dot (..) Symbol (Beginner)

Task: Navigate to ~/path-practice/project/src, then go up one level using ...

# Navigate to src
cd ~/path-practice/project/src
pwd
# Output: /home/centos9/path-practice/project/src

# Go up one level
cd ..
pwd
# Output: /home/centos9/path-practice/project

# Go up another level
cd ..
pwd
# Output: /home/centos9/path-practice

# Go up two levels at once
cd project/src    # Back to src
cd ../..
pwd
# Output: /home/centos9/path-practice

Lab 7: Using the Tilde (~) Symbol (Beginner)

Task: From /tmp, navigate to your home directory using ~.

# Go to /tmp
cd /tmp
pwd
# Output: /tmp

# Navigate to home using ~
cd ~
pwd
# Output: /home/centos9

# Navigate to subdirectory of home from anywhere
cd /var/log
cd ~/path-practice
pwd
# Output: /home/centos9/path-practice

Lab 8: Copying with Parent Directory (Intermediate)

Task: From ~/path-practice/project/src, copy a file to the parent directory (project).

# Navigate to src
cd ~/path-practice/project/src

# Create a test file
touch testfile.txt

# Copy to parent directory
cp testfile.txt ..

# Verify
ls ..
# Should show: docs src tests testfile.txt

# Or verify with absolute path
ls ~/path-practice/project/

Lab 9: Listing Parent Directory (Intermediate)

Task: From ~/path-practice/project/src, list the contents of the parent directory without changing location.

# Navigate to src
cd ~/path-practice/project/src
pwd
# Output: /home/centos9/path-practice/project/src

# List parent directory
ls ..
# Output: docs src tests

# List grandparent directory
ls ../..
# Output: backups downloads project

# Verify you're still in src
pwd
# Output: /home/centos9/path-practice/project/src

Lab 10: Complex Relative Navigation (Intermediate)

Task: Navigate from ~/path-practice/project/src to ~/path-practice/backups using only relative paths.

# Start in src
cd ~/path-practice/project/src
pwd
# Output: /home/centos9/path-practice/project/src

# Navigate to backups (relative)
cd ../../backups

# Breakdown:
# ..        -> /home/centos9/path-practice/project
# ../..     -> /home/centos9/path-practice
# ../../backups -> /home/centos9/path-practice/backups

pwd
# Output: /home/centos9/path-practice/backups

Lab 11: Using cd - (Intermediate)

Task: Navigate between two directories using cd - to toggle.

# Start at home
cd ~
pwd
# Output: /home/centos9

# Go to /etc
cd /etc
pwd
# Output: /etc

# Toggle back
cd -
pwd
# Output: /home/centos9

# Toggle again
cd -
pwd
# Output: /etc

# Toggle back
cd -
pwd
# Output: /home/centos9

Lab 12: Absolute vs Relative Comparison (Intermediate)

Task: Copy /etc/hosts to ~/path-practice/backups using both absolute and relative paths.

# Method 1: All absolute paths
cp /etc/hosts /home/centos9/path-practice/backups/

# Method 2: Absolute source, relative destination
cd ~/path-practice
cp /etc/hosts backups/

# Method 3: Using ~
cp /etc/hosts ~/path-practice/backups/

# Verify all methods worked
ls ~/path-practice/backups/hosts

Lab 13: Nested Directory Creation (Intermediate)

Task: Create ~/path-practice/project/src/components/buttons using both absolute and relative paths.

# Method 1: Absolute path
mkdir -p /home/centos9/path-practice/project/src/components/buttons

# Method 2: Using ~
mkdir -p ~/path-practice/project/src/components/buttons

# Method 3: Relative (from path-practice)
cd ~/path-practice
mkdir -p project/src/components/buttons

# Verify
ls -R ~/path-practice/project/src/

Lab 14: Path Resolution Practice (Advanced)

Task: Starting from /home/centos9/path-practice/project/src, resolve where ../../downloads/file.txt points to.

cd ~/path-practice/project/src
touch ../../downloads/file.txt
ls ../../downloads/
# Output: file.txt

# Check absolute path
ls ~/path-practice/downloads/
# Output: file.txt

Lab 15: Copying Between Sibling Directories (Advanced)

Task: Copy a file from ~/path-practice/project/src to ~/path-practice/project/tests using relative paths.

# Navigate to src
cd ~/path-practice/project/src

# Create test file
touch testfile.js

# Copy to sibling directory (tests)
cp testfile.js ../tests/

# Breakdown:
# ..         -> parent (project)
# ../tests/  -> sibling directory

# Verify
ls ../tests/
# Output: testfile.js

Lab 16: Using . in find Command (Advanced)

Task: Use find to search for all .txt files starting from the current directory.

# Navigate to path-practice
cd ~/path-practice

# Create some .txt files
touch project/file1.txt
touch backups/file2.txt
touch downloads/file3.txt

# Find all .txt files from current directory
find . -name "*.txt"

# Output:
# ./project/file1.txt
# ./backups/file2.txt
# ./downloads/file3.txt
# ./project/src/../../downloads/file.txt (if exists)

# The . means "start searching from here"

Lab 17: Home Directory in Scripts (Advanced)

Task: Create a script that copies a file to your home directory backup folder.

# Create backup directory
mkdir -p ~/backups

# Create script
cat > backup.sh << 'EOF'
#!/bin/bash
# Backup script using ~ and $HOME

# Using ~ (works interactively and in scripts)
cp /etc/hostname ~/backups/hostname.backup

# Using $HOME (more portable in scripts)
cp /etc/hosts "$HOME/backups/hosts.backup"

echo "Files backed up to $HOME/backups/"
EOF

# Make executable
chmod +x backup.sh

# Run script
./backup.sh

# Verify
ls ~/backups/

Lab 18: Copying with Complex Paths (Advanced)

Task: From /tmp, copy ~/path-practice/project/src/testfile.txt to ~/path-practice/backups/ using at least one relative path component.

# Navigate to /tmp
cd /tmp

# Create the source file first
touch ~/path-practice/project/src/testfile.txt

# Copy (source absolute, destination with ~)
cp ~/path-practice/project/src/testfile.txt ~/path-practice/backups/

# Verify
ls ~/path-practice/backups/
# Output: testfile.txt

# Alternative using $HOME
cp "$HOME/path-practice/project/src/testfile.txt" "$HOME/path-practice/backups/"

Lab 19: Understanding Symbolic Link Paths (Advanced)

Task: Create a symbolic link and understand how paths work with links.

# Create a file
cd ~/path-practice
echo "test content" > downloads/original.txt

# Create symbolic link using relative path
ln -s downloads/original.txt link_to_file.txt

# List with details
ls -l link_to_file.txt
# Output: link_to_file.txt -> downloads/original.txt

# Access via link
cat link_to_file.txt
# Output: test content

# Create absolute symlink
ln -s /home/centos9/path-practice/downloads/original.txt absolute_link.txt

ls -l absolute_link.txt
# Output: absolute_link.txt -> /home/centos9/path-practice/downloads/original.txt

Lab 20: Real-World Script Path Management (Advanced)

Task: Create a deployment script that works correctly regardless of where it's executed from.

# Create script
cat > deploy.sh << 'EOF'
#!/bin/bash
# Deployment script with proper path management

# Get script's directory (absolute path)
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"

# Use absolute paths for critical operations
SOURCE_DIR="/etc/myapp"
DEST_DIR="$HOME/backups/myapp-$(date +%Y%m%d)"

# Create destination
mkdir -p "$DEST_DIR"

# Copy files (absolute paths)
if [ -f "$SOURCE_DIR/config.txt" ]; then
    cp "$SOURCE_DIR/config.txt" "$DEST_DIR/"
    echo "Copied config to $DEST_DIR"
else
    echo "Warning: config.txt not found"
fi

# Log where script was run from
echo "Script executed from: $(pwd)"
echo "Script location: $SCRIPT_DIR"
echo "Backup location: $DEST_DIR"
EOF

chmod +x deploy.sh

# Test from different locations
cd /tmp
~/path-practice/deploy.sh

cd ~
./path-practice/deploy.sh

📚 Best Practices

🚨 Common Pitfalls to Avoid

Pitfall 1: Wrong Path Type

# Wanted absolute, typed relative
cat etc/passwd
# Error: No such file or directory

# Fix: Add leading slash
cat /etc/passwd

Pitfall 2: Wrong Current Directory

# Think you're in ~/documents
# Actually in /tmp

touch file.txt    # Creates /tmp/file.txt, not ~/documents/file.txt

# Always check:
pwd

Pitfall 3: Forgetting Quotes with Spaces

# Path with spaces
cd ~/My Documents
# Error: cd: too many arguments

# Fix: Quote the path
cd "~/My Documents"
# or
cd ~/My\ Documents

Pitfall 4: Using Relative Paths in Scripts

#!/bin/bash
# Bad: depends on where script is run from
cp config.txt backups/

# Good: absolute paths
cp /etc/myapp/config.txt /var/backups/myapp/

Pitfall 5: Too Many ../../../

# Hard to read
cd ../../../../../../../somewhere

# Better: use absolute or ~
cd /somewhere
# or
cd ~/somewhere

📝 Command Cheat Sheet

# ===== ABSOLUTE PATHS =====
cd /etc                          # Navigate to /etc
cp /etc/hosts /tmp/              # Copy using absolute paths
ls /var/log                      # List using absolute path

# ===== RELATIVE PATHS =====
cd documents                     # Navigate to subdirectory
cp file.txt ../                  # Copy to parent
ls ../../                        # List grandparent

# ===== CURRENT DIRECTORY (.) =====
cp /etc/hosts .                  # Copy to current directory
./script.sh                      # Execute script in current directory
find . -name "*.txt"             # Search from current directory

# ===== PARENT DIRECTORY (..) =====
cd ..                            # Go up one level
cd ../..                         # Go up two levels
cp file.txt ..                   # Copy to parent
ls ../sibling/                   # List sibling directory

# ===== HOME DIRECTORY (~) =====
cd ~                             # Go to home
cd                               # Also goes to home
cp file.txt ~/backups/           # Copy to home subdirectory
ls ~/documents                   # List home subdirectory

# ===== TOGGLE DIRECTORIES =====
cd -                             # Return to previous directory

# ===== COMBINING SYMBOLS =====
cp ~/documents/file.txt ../backups/
cd ../../other/path
mkdir -p ~/project/{src,tests,docs}

# ===== PATH VARIABLES =====
echo $HOME                       # Show home directory
echo $PWD                        # Show current directory
echo $OLDPWD                     # Show previous directory
cd $HOME                         # Navigate using variable

# ===== VERIFICATION =====
pwd                              # Show current absolute path
realpath .                       # Show absolute path of current
readlink -f somefile             # Show absolute path of file

# ===== SCRIPT-SAFE PATHS =====
# Use absolute paths
cp /etc/config /var/backups/

# Or use variables
cp "$HOME/file.txt" "$HOME/backups/"

# Get script's directory
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"

🎯 Key Takeaways

🚀 What's Next?

You've mastered Linux paths—one of the most fundamental concepts in Linux! You now understand how to navigate efficiently using both absolute and relative paths, and you know the special symbols that make navigation easier.

In the next post, we'll explore Moving and Renaming Files with mv, including:

• Basic mv syntax for moving files
• Renaming files and directories
• Moving across filesystems
• Interactive and verbose modes
• Batch moving with wildcards
• Understanding mv vs cp differences
• Safe moving practices

All the path knowledge you've learned will be directly applicable to mastering the mv command!