Chapter 4: Command-Line Fundamentals

Updated

October 31, 2026

Chapter 4: Command-Line Fundamentals

The Linux command line is the definitive interface for systems engineering, automation, and infrastructure operations.

In Ubuntu 26.04 LTS, the command-line environment balances classic POSIX compliance with cutting-edge safety innovations: modern terminal emulation via Ptyxis, high-performance package resolution with APT 3, memory-safe administrative escalation with sudo-rs, and drop-in Rust-based core utilities via uutils.

This chapter covers the shell environment, essential commands, the Filesystem Hierarchy Standard, permissions, modern package management, memory-safe tooling, pipelines, and scripting basics.

The Shell: Bash and Ptyxis

Ubuntu 26.04 LTS uses Bash 5.3+ as the default interactive shell, paired with Ptyxis as the default graphical terminal.

Ptyxis: The Container-Aware Terminal

Unlike legacy terminals, Ptyxis is built from the ground up for containerized and immutable workflows: - Automatic Container Detection: Seamlessly detects local Podman pods, Docker engines, Distrobox sandboxes, and LXD containers. - Per-Container Tabs: A single window can host tabs running inside an Ubuntu 26.04 host shell, a Fedora toolbox, and an Alpine development container. - Hardware-Accelerated Glyphs: Renders fast text and ligature fonts via GTK4 and OpenGL/Vulkan.

# Verify shell environment and bash version
echo $SHELL
bash --version | head -n 1
# GNU bash, version 5.3.0(1)-release (x86_64-pc-linux-gnu)

Essential Commands

Proficiency in the command line begins with mastering core filesystem and administrative commands:

# Navigation and Directory Inspection
pwd                 # Print working directory
ls -la              # List detailed contents including hidden dotfiles
cd /var/log         # Change current directory

# File Creation and Manipulation
mkdir -p dev/src    # Create nested directories
touch dev/src/app.c # Create empty file or update timestamp
cp -r dev/ backup/  # Recursive copy directory
mv backup/ old_bck/ # Move or rename directory
rm -rf old_bck/     # Remove directory recursively and forcefully

# File Content Inspection
cat /etc/os-release # Dump entire file content to stdout
head -n 5 /etc/passwd # Display first 5 lines
tail -f /var/log/syslog # Follow end of log file in real time
less /etc/services  # Interactive pager (navigate with / and q)

The Filesystem Hierarchy Standard (FHS)

Linux organizes data in a unified hierarchical tree starting at root (/):

Path Purpose Persistence
/bin & /sbin Essential user and administrative binaries (symlinked to /usr/bin) Read-Only OS
/usr Secondary hierarchy containing user programs, libraries, and docs Read-Only OS
/etc Host-specific system-wide configuration files Persistent
/home User personal directories and configuration dotfiles Persistent
/var Variable data: logs (/var/log), caches, databases (/var/lib) Persistent
/tmp Temporary files (mounted in RAM via tmpfs; wiped on reboot) Ephemeral
/run Runtime state data for running daemons (mounted via tmpfs) Ephemeral
/dev Device nodes representing physical and virtual hardware Dynamic (devtmpfs)
/proc Virtual filesystem exposing kernel process and memory state In-Memory Kernel
/sys Virtual filesystem exposing kernel device and driver topology In-Memory Kernel

Permissions, Ownership, and Special Bits

Every file and directory possesses an owner, an owning group, and a 9-bit permission mask:

┌────────────────────────────────────────────────────────────────────────┐
│                      LINUX PERMISSION BIT STRUCTURE                    │
│                                                                        │
│   -  r w x  r - x  r - -                                               │
│   │  ─────  ─────  ─────                                               │
│   │    │      │      │                                                 │
│   │    │      │      └─ Others Permissions (Read Only = 4)             │
│   │    │      └──────── Group Permissions (Read + Execute = 5)         │
│   │    └─────────────── User/Owner Permissions (Read+Write+Exec = 7)   │
│   └──────────────────── File Type (- = Regular file, d = Directory)    │
│                                                                        │
│   Octal Notation: 754                                                  │
└────────────────────────────────────────────────────────────────────────┘
# Modify file ownership
sudo chown alice:developers /opt/service.py

# Modify permission bits using symbolic and octal notation
chmod 750 /opt/service.py      # rwxr-x---
chmod +x /opt/service.py       # Add execute bit to all categories
chmod u+rw,g+r,o-rwx /opt/data # Explicit user/group/other assignment

# Special Bits: SUID, SGID, and Sticky Bit
chmod u+s /usr/local/bin/prog  # SUID: Executes with binary owner privilege
chmod g+s /shared/folder/      # SGID: New files inherit parent group ownership
chmod +t /shared/tmp/          # Sticky bit: Only file owners can delete files

Package Management with APT 3

Ubuntu 26.04 LTS introduces APT 3.0, featuring a completely overhauled dependency solver and structured visual output:

┌────────────────────────────────────────────────────────────────────────┐
│                        APT 3.0 ENHANCEMENTS                            │
│                                                                        │
│   1. Columnar Layout: Distinct tables for upgrades, additions, removals │
│   2. SAT-Based Solver: Resolves complex dependency trees 5x faster     │
│   3. Explicit Security Gating: Visually highlights unsigned sources    │
└────────────────────────────────────────────────────────────────────────┘

Common administrative commands:

# Update repository package metadata indexes
sudo apt update

# Perform a full distribution upgrade with dependency resolution
sudo apt full-upgrade -y

# Search for packages matching keyword
apt search nginx

# Install a specific package
sudo apt install -y htop

# Remove a package while preserving configuration files
sudo apt remove htop

# Remove a package and purge all associated /etc configuration
sudo apt purge htop

# Automatically remove unneeded orphan dependencies
sudo apt autoremove --purge -y

Rust-Based Core Utilities (uutils)

To mitigate decades-old memory corruption risks in C-based core utilities, Ubuntu 26.04 LTS includes uutils—a drop-in replacement for GNU coreutils implemented in safe Rust:

# Verify uutils coreutils presence
uutils --version

# Run memory-safe utilities directly or through symlinked path
uutils ls -la
uutils cat /etc/hosts
  • Performance: Matches or exceeds GNU coreutils through SIMD vectorization and Rust’s zero-cost abstractions.
  • Safety: Immune to buffer overruns, off-by-one pointer writes, and uninitialized memory disclosures.

sudo-rs: Memory-Safe Privilege Escalation

Administrative privilege escalation in Ubuntu 26.04 LTS is powered by sudo-rs, a ground-up reimplementation of sudo developed jointly by Prossimo and Canonical in safe Rust.

┌────────────────────────────────────────────────────────────────────────┐
│                      SUDO-RS PRIVILEGE MEDIATION                       │
│                                                                        │
│  User runs: sudo -u postgres psql                                      │
│      │                                                                 │
│      ▼                                                                 │
│  [ sudo-rs (Memory-Safe Rust Runtime) ]                                │
│      ├─ 1. Authenticates user via PAM stack (/etc/pam.d/sudo)          │
│      ├─ 2. Parses /etc/sudoers with formal grammar AST                 │
│      ├─ 3. Verifies command constraints, environment, and user groups │
│      └─ 4. Calls setuid()/execve() in isolated child process           │
└────────────────────────────────────────────────────────────────────────┘

Configuring privileges in /etc/sudoers (always edit via visudo):

# Allow members of group 'wheel' to run all commands without password
%wheel ALL=(ALL:ALL) NOPASSWD: ALL

# Restrict user 'backup' to run only restic backups as root
backup ALL=(root) /usr/local/bin/restic-backup.sh

Text Processing and Pipelines

The power of the UNIX philosophy lies in chaining small, focused tools through standard I/O streams (stdin, stdout, stderr):

# Pipeline: Find 10 largest directories under /var
du -h /var 2>/dev/null | sort -rh | head -n 10

# Grep with Regular Expressions
grep -E "(ERROR|CRITICAL)" /var/log/syslog | grep -v "test"

# AWK: Extract IPs from access log and count unique occurrences
cat /var/log/nginx/access.log | awk '{print $1}' | sort | uniq -c | sort -nr | head -n 5

# Sed: Search and replace string inline in configuration file
sed -i 's/Listen 80/Listen 8080/g' /etc/apache2/ports.conf

Shell Scripting Basics

Create an automated, robust maintenance script:

#!/usr/bin/env bash
# system_health.sh - Basic administrative health check
set -euo pipefail

LOGFILE="/var/log/system_health.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

echo "=== System Health Check at ${TIMESTAMP} ===" | tee -a "${LOGFILE}"

# Check root filesystem disk usage
DISK_USAGE=$(df -h / | awk 'NR==2 {print $5}' | tr -d '%')
if [ "${DISK_USAGE}" -gt 85 ]; then
    echo "[WARNING] Root partition usage is high: ${DISK_USAGE}%" | tee -a "${LOGFILE}"
else
    echo "[OK] Root partition usage is normal: ${DISK_USAGE}%" | tee -a "${LOGFILE}"
fi

# Check system load average
LOAD=$(cut -d ' ' -f 1-3 /proc/loadavg)
echo "[INFO] Current Load Average (1, 5, 15 min): ${LOAD}" | tee -a "${LOGFILE}"

Make executable and run:

chmod +x system_health.sh
./system_health.sh

Chapter Summary

  • Bash 5.3 and Ptyxis provide a modern, container-aware command-line environment.
  • The FHS provides a standardized layout separating static binaries, persistent data, and in-memory kernel pseudofilesystems.
  • APT 3 introduces a modernized SAT-based dependency solver with enhanced columnar output.
  • Memory safety is achieved in userspace through sudo-rs and Rust-based uutils core utilities.
  • Shell pipelines and Bash scripting automate administrative tasks with zero external dependencies.