← Back to Recording

Summary

Overview

This is a hands-on Linux command-line fundamentals course designed to build practical proficiency in shell operations, file system navigation, command chaining, redirection, and basic scripting. The session covers alias management, command sequencing with semicolons and logical operators, piping for output filtering, standard output/error redirection, the use of /dev/null, live file monitoring with tail -f and watch, file permission management, script creation and execution, and advanced file searching with find. The instructor emphasizes real-world use cases, common pitfalls, and the importance of reading manual pages, culminating in an introduction to automation through scripting.

Topic (Timeline)

1. Alias Management and Command Execution [00:00:28 - 00:02:37]

  • Introduced the concept of shell aliases (e.g., cp aliased to cp -i).
  • Demonstrated that directly invoking the full path to an executable (e.g., /bin/cp) bypasses the alias.
  • Emphasized that aliases are convenience tools for interactive use and do not affect direct path execution.
  • Reinforced the purpose of aliases: to simplify complex or frequently used commands.

2. Command Sequencing and Conditional Execution [00:02:39 - 00:07:29]

  • Explained how to chain multiple commands using semicolons (;) — executes all regardless of success.
  • Introduced logical operators: && (execute next only if previous succeeds) and || (execute next only if previous fails).
  • Demonstrated with touch and cd commands: failed cd due to existing file prevents subsequent command.
  • Clarified that && and || provide conditional logic between commands, unlike semicolons.
  • Encouraged hands-on practice with command chaining and exit code logic.

3. Piping and Output Filtering with grep [00:07:31 - 00:14:38]

  • Defined piping (|) as passing output of one command as input to another.
  • Demonstrated ls -l | wc -l to count lines of directory listing.
  • Introduced grep for filtering text: grep localhost /etc/hosts to show matching lines.
  • Showed inverse filtering with grep -v localhost to exclude lines.
  • Highlighted case-insensitive search with grep -i.
  • Combined ls -l /etc | grep -i feb to find configuration files modified in February.
  • Warned that options (e.g., -v) vary by command — do not assume universal meaning (e.g., -v is not always verbose).

4. Redirection: Standard Output, Standard Error, and /dev/null [00:17:08 - 00:27:46]

  • Explained > (redirect stdout) and 2> (redirect stderr).
  • Demonstrated that command > file captures only successful output; errors remain on terminal.
  • Showed command > file 2>&1 to redirect both stdout and stderr to a file.
  • Introduced file descriptors: 1 = stdout, 2 = stderr.
  • Demonstrated command > file 2> /dev/null to discard errors silently.
  • Explained /dev/null as a black hole that discards all input.
  • Warned that > overwrites files; use >> to append.

5. File System Navigation, History, and Append Operations [00:29:04 - 00:33:14]

  • Clarified that redirection targets (> file) do not require the file to pre-exist — it is created if absent.
  • Warned that repeated > overwrites content; use >> for appending.
  • Introduced command history: !n to re-execute command by line number from history.
  • Demonstrated history to view command list and ! shortcuts for quick recall.
  • Emphasized that mastering these features improves efficiency and reduces repetitive typing.

6. Live Monitoring: tail -f and watch [00:34:01 - 00:42:35]

  • Introduced tail -f filename to continuously display new lines appended to a log file.
  • Demonstrated real-time log monitoring by appending text to a file while tail -f runs.
  • Introduced watch command to repeatedly execute and display output (default every 2 seconds).
  • Showed watch -n 1 date to monitor time changes and watch -d ls /tmp to highlight differences.
  • Clarified: tail -f watches file content changes; watch repeatedly runs a command.
  • Noted Ctrl+C to terminate both.

7. Script Creation, Permissions, and Execution [00:44:25 - 00:52:42]

  • Created a text file containing shell commands (e.g., hostname, uname -a).
  • Demonstrated that a text file is not executable by default.
  • Showed that running bash /path/to/script executes it via shell interpreter.
  • Used chmod +x scriptname to add execute permission to the file.
  • Demonstrated execution via ./scriptname after setting permissions.
  • Emphasized that scripts require both correct content and proper file permissions to run directly.

8. Advanced File Searching with find [00:56:38 - 01:03:07]

  • Introduced find with two core parameters: starting path and search criteria.
  • Demonstrated find /path -name "*.conf" to locate files by name pattern.
  • Showed use of -type f (files), -type d (directories), -user username, -mtime -7 (modified in last 7 days).
  • Explained -exec to run commands on found files (e.g., find . -name "*.log" -exec rm {} \;).
  • Warned of high risk with -exec — recommend testing with -print first.
  • Advised using man find to explore full expression syntax (e.g., -size, -perm, -atime).

9. locate, inodes, and System Tools [01:03:44 - 01:07:19]

  • Contrasted find (real-time traversal) with locate (uses pre-built database; faster but may be outdated).
  • Noted locate may not be installed by default and requires updatedb to refresh index.
  • Explained inodes as unique identifiers for files on disk.
  • Demonstrated that hard links point to the same inode — multiple names for same data.
  • Clarified that inode numbers are visible in ls -i output and are key to understanding hard links.

10. Background Processes, nohup, and System Context [01:07:29 - 01:12:26]

  • Introduced nohup command & to run processes that survive shell logout.
  • Explained that nohup detaches the process from the terminal and redirects output to nohup.out.
  • Noted that screen and tmux are modern alternatives for session persistence.
  • Discussed Unix vs. Linux evolution: modern Unix systems now adopt Linux features.
  • Emphasized enterprise platform choices are based on stability, ecosystem, and long-term goals, not user preference.

11. Course Wrap-up and Final Thoughts [01:12:26 - 01:13:58]

  • Concluded with encouragement to explore the terminal more confidently.
  • Reinforced that mastery comes from practice, reading man pages, and experimenting.
  • Acknowledged participant engagement and thanked attendees.
  • Noted that the session was structured as a workshop — hands-on practice was the primary goal.

Appendix

Key Principles

  • Aliases are interactive conveniences; they do not affect direct path execution.
  • Semicolons (;) run commands sequentially; && and || add conditional logic.
  • Pipes (|) enable chaining commands for filtering and processing output.
  • Redirection separates stdout (>) and stderr (2>); use 2>&1 to combine.
  • /dev/null discards unwanted output — useful for silencing errors or logs.
  • tail -f monitors file growth; watch repeatedly executes a command.
  • Scripts require execute permission (chmod +x) to run directly.
  • find is powerful for recursive searches; use -exec, -name, -type, -mtime for precision.
  • locate is faster than find but relies on a database that may be outdated.
  • Inodes uniquely identify files; hard links share the same inode.
  • nohup allows processes to survive terminal disconnection.

Tools Used

  • alias, unalias
  • ;, &&, ||
  • |, grep, wc, ls
  • >, >>, 2>, 2>&1, /dev/null
  • tail -f, watch, watch -d
  • chmod, nano, vi
  • find, locate
  • nohup, history, !n
  • uname, hostname, echo, touch, cd, mkdir

Common Pitfalls

  • Assuming -v means “verbose” across all commands — it means “invert match” in grep.
  • Using > instead of >> and accidentally overwriting log files.
  • Forgetting to set execute permissions on scripts.
  • Running find / on large systems without limiting scope — causes performance issues.
  • Typing “EOF” literally instead of pressing Ctrl+D to send end-of-file signal.
  • Confusing watch (repeats a command) with tail -f (monitors file changes).

Practice Suggestions

  • Create aliases for your most-used commands and test bypassing them with full paths.
  • Chain 3+ commands using && and || to handle success/failure scenarios.
  • Use ls -l /var/log | grep -i error to find error logs.
  • Redirect output of a failing command to a file and observe what gets saved.
  • Write a script that checks disk usage, lists recent files, and logs the result.
  • Use find /home -name "*.tmp" -mtime +30 -delete (test first with -print).
  • Run watch -n 1 'ps aux | grep python' to monitor Python processes.
  • Use nohup ping google.com & and log out — then log back in to verify it’s still running.