Introducing Linux Command Line and Practical Shell Scripting

Master vim navigation by switching between normal and insert modes, using hjkl, moving by word and paragraph, searching with / and n, and saving with :wq.

Install Vim on Ubuntu, macOS, or Windows, then practice basic navigation using h j k l, w, b, 0, and $, enter insert mode with i, and exit with :q.

Learn vim basics: navigate the document, search with hlsearch, copy and paste with y and p, and insert, append, or open lines with i, A, and o.

Practice vim navigation for editing longer documents: jump between paragraphs with curly braces, move to line starts/ends with 0 and $, and to file ends with gg or G.

Master advanced vim navigation and editing by locating Python occurrences with / and n/N, deleting with dw and D, and inserting new lines with O/o, and undoing with U.

Master Vim search and replace, copy and insert text across files, using percent substitutions, global flags, and optional line ranges with confirmation for precise edits.

Learn practical Vim copy and insert techniques, including yank and paste with y, yy, and p or P, repeat with counts, undo with U, and edit lines, words, and files.

Master vim's modal editing by switching between normal and insert modes, perform efficient navigation, editing, and search and replace, and use yanking, changing text, and repeat with dot commands.

Explore the powerful world of vim through basic and advanced editing techniques, from creating and editing files to navigation, text manipulation, and efficient workflows using commands, visual modes, and substitutions.

practice text editing in vim by creating a file, entering insert mode, pasting text, deleting, undoing, and replacing words. navigate, search, and use commands to modify lines in shell scripting.

Learn practical vim editing skills on the linux command line, including searching, visual selection, deleting, inserting, and reordering sections to organize scripting languages and system administration content.

Practice editing in vim by deleting lines, replacing scripting with programming, and adjusting indentation; learn search and replace, yank and paste, change inside parentheses, and visual selections.

Master advanced Vim techniques for efficient editing: jump to specific lines, navigate in multi-window mode, search by pattern, use read-only mode, and repeat edits with the dot command.

Create multiple files, open them in vim, navigate between them with :next and :previous, split windows horizontally and vertically, and save all changes with :wqa.

Learn advanced Vim workflows for managing multiple files: split windows, diff two configs, edit across three buffers with bufdo, and apply global changes across all buffers.

Learn to install and configure git on linux, generate an SSH key, add it to GitHub, and push your local project files by cloning, adding, committing, and pushing via SSH.

Master vim essentials: switch between insert and normal modes, navigate with h j k l and word movements, and edit using search, replace, and visual mode.

learn to write and run your first bash script, including creating the file, making it executable, and running it, with hands-on guidance on shebang, echo, and command substitution.

Learn to chmod a bash script to executable, run it with bash or dot slash, and use a shebang for portability, then expand with user input and variables.

Explore bash syntax fundamentals, including variables, data types, command substitution, quoting, and special variables, with hands-on examples and troubleshooting.

Bash treats everything as a string, but contexts can trigger numeric operations. Practice with strings, arrays, arithmetic using $((num1+num2)) and command substitution with $() or backticks.

Learn bash special variables such as script name, positional parameters, argument count, all arguments, exit status, and process ID, and explore command substitution through a hands-on script.

Navigate the unix-like file system with bash by mastering pwd, ls, cd, mkdir, touch, cp, mv, and rm; understand root and home structure and manage file permissions.

Explore file permissions in unix-like systems, including owner, group, and others, using ls, touch, and chmod. Learn symbolic and numeric methods to grant read, write, and execute access.

Build a practical bash script to create a project directory structure with mkdir, touch, and vim, then set and verify permissions with chmod and ls -R and ls -l.

Develop and dissect an enhanced file operations script that uses special variables, command substitution, user input, timestamps, and file permissions, then modify bashrc and review script behavior.

Explore bash conditional statements using the if structure, add else and elif, and write scripts that check file existence, compare numbers, and build a simple checker.

Explore bash condition testing with file, string, and numeric tests, including -f, -d, -r, -z, -n, and comparison operators, then combine conditions using and and or.

Explore bash loops—for, while, and until—through practical scripts that count, process files, and demonstrate break and continue, including nested loops for complex tasks.

Explore bash loops, including until, while, and for loops, with break and continue. See nested loops and a practical example processing all dot txt files in a directory.

Join a hands-on Linux lab to build a bash interactive menu script for system administration, iteratively adding features like a clear screen option and a simple game while practicing debugging.

Build an interactive bash menu in a hands-on lab, adding clear screen and a guess-the-number game, with case statements, while loops, and user input.

Build a Linux system administration interactive menu script using bash to perform uptime, disk usage, top cpu processes, memory, and logs via a persistent menu loop.

Build a Linux administration interactive menu script using bash, case statements, and read to handle input. Explore options like uptime, disk usage, load average, and large file searches with sudo.

Master bash functions as building blocks by defining and calling with parameters, returning values, and using local variables, illustrated with greetings, calculations, and a number guessing game.

Master bash functions by using the local keyword to control scope, explore even or odd checks and random number generation, and learn to build reusable scripts.

Master error handling and debugging in Bash, from exit statuses and traps to custom functions, verbose output, and the Bash debugger, with practical, robust scripting examples.

Explore error handling and debugging in bash, part 2, through practical techniques such as set -e, custom error functions, redirecting errors to stderr, and using traps for cleanup.

Master bash debugging techniques using set -x for verbose output and debug echoes. Implement error handling, cleanup with traps, and practice with non-existent files to improve script reliability.

Explore advanced bash scripting techniques with practical examples, including parameter expansion, indirect reference, associative arrays, process substitution, brace expansion, and input-output redirection. Parse options and manage subshells.

Master advanced bash scripting techniques on the Linux command line, including indirect references, associative arrays, array slicing, and array operations. Apply process substitution and brace expansion through practical examples.

Explore advanced bash scripting techniques, including input/output redirection, here documents, subshells and command grouping, traps and signals, recursive functions, and parsing command-line options with getopts, with practical examples.

Explore advanced Bash scripting techniques through a practical example, including associative arrays, a recursive traverse function, trap cleanup, here documents, and identifying the most common file extension.

Explore bash script optimization and performance techniques, including built-in commands, avoiding unnecessary commands, shell arithmetic, double brackets, and command grouping, with profiling and practice for large data sets.

Explore bash script optimization techniques, using arrays for large data sets, read with a string for multi-line parsing, and awk, sort -u, grep -F, and parallel for speed.

Profile bash scripts to optimize performance with the time command and set -x, then demonstrate printf, shell arithmetic, command substitution, awk, grep, and sort.

Practice bash script optimization and performance by debugging typos, and generating data.csv, large_underscore_file.txt, and names.txt with practical shell scripts.

Improve bash script performance by combining data generation, large file handling, and names creation while measuring before and after optimization. Emphasize readability and maintainability to troubleshoot errors effectively.

Learn to write simple bash scripts to automate command sequences, use loops, conditionals, grep and regular expressions, and master quoting, shebang, and execution permissions for efficient Linux command line workflows.

Learn to create and run a bash script with vim, add a shebang and echo outputs to output.txt, then make it executable and run with sh or ./script.sh.

Master for loops in bash to iterate over lists, track exit codes, and implement if, elif, and else conditionals using test operators.

Use loops to print hostnames from multiple servers by iterating a list with a for loop in the command line and in a shell script, using ssh and hostname.

Explore regular expressions for text matching in command output and files, using grep, vim, and less, with syntax, anchors, wildcards, and examples across Perl, Python, and C.

Explore practical grep techniques with regex to locate postfix activity in system logs, filter by date and time, inspect config files, and verify postfix processes with ps and master.cf entries.

Learn to use grep with regular expressions to match data, protect patterns with single quotes, and pipe results, using options -i, -v, -R, -E, and -e for flexible file searches.

Create a bash script to collect system info from two hosts using hostname -f, lscpu, and regex-filtered output from /etc/selinux/config and /var/log/secure, loop over servers, and save results to files.

Learn to build and run linux shell scripts using echo with quotes, variables, command substitution, and inline input redirection to generate dynamic logs and display system information.

Explore how if-then statements drive bash scripting, using exit status, then and else blocks, nesting, elif, and practical examples like PWD and grep in the /etc/passwd file.

Explore how the test command drives if statements in bash, using numeric, string, and file comparisons; learn to use square brackets, escape characters, and handle empty or uninitialized variables.

Learn to test file and directory status in Linux shell scripts using common file tests (-d, -e, -f, -r, -s, -w, -x, -o, -G) and date comparisons (-nt, -ot).

Develop mastery of bash if-then statements by using and or boolean operators, subshells with single parentheses, double parentheses for arithmetic, and double brackets for string pattern matching.

Learn to replace lengthy if-then-else chains with the case command for multi-pattern matching and see a practical script that detects package managers and infers the Linux distribution base.

Demonstrates the bash for loop, iterating values with for var in list; do ... done, and covers reading lists from variables or commands and handling quotes and spaces.

Explore looping with the for statement, including adjusting the IFS field separators to handle spaces and newlines, using file globbing and wildcards, and employing C-style for loops with multiple variables.

Master while and until loops in Bash by testing conditions with the test command and exit status, including nested loops, to prevent infinite loops.

Master nested loops with IFS and the for command to parse file lines, control flow with break and continue, and redirect or pipe output to sort Etsy password file.

Explore practical loop examples in shell scripting, using for and while loops to scan the path environment variable for executables and to create user accounts from a CSV file.

Learn how to pass data to bash scripts using command line parameters and positional parameters, including dollar zero and dollar one, with handling of spaces using quotes.

Discover how to manage bash command line parameters with special variables like $# , $*, and $@, verify counts with if statements, and use shift to iterate through arguments.

Master processing command line options and parameters in shell scripts using case statements and double dash separation. Explore handling options with values, using getopt/getopts, and common Linux option patterns.

Master the read command to prompt for and capture user input in shell scripts, support multiple variables, silent input, and input from files.

Explore a practical shell script that pings multiple IP addresses to test connectivity, selectable via command line options or a file, using getopts and read for interactive input.

Explore the Linux command line inputs and outputs, learn to redirect stdout and stdin, separate stdout and stderr with file descriptors and redirection, and combine outputs for effective scripting.

Master output control in Linux scripts by redirecting stdout and stderr with file descriptors, using temporary and permanent redirection, and redirecting stdin for data processing.

Redirect input and output with file descriptors, save and restore stdin, and read and write using the same descriptor. Learn about closing descriptors and listing open fds with lsof.

Learn to suppress script output with /dev/null, create and manage temporary files and directories using mktemp in /tmp, and log output to monitor and a file with the t command.

Explore practical file redirection in bash by reading a csv file and generating sql insert statements, using a while loop with read and IFS, redirecting stdout and stderr.

Learn how to run and control shell scripts using signals in bash, including sighup, sigint, and sigterm, with ctrl+c, ctrl+z, and kill to interrupt or pause processes.

Use the trap command to watch Linux signals and intercept them with custom actions. Trap Sigint and exit, modify and remove traps, and explore trap -P to view trapped signals.

Learn to run shell scripts in the background with an ampersand, see job numbers and pids, and keep them running after logout using nohup, redirecting stdout and stderr.

Learn how to start a shell script in the background with nohup, which blocks sighup signals, redirects stdout and stderr to nohup.out, and lets you log out.

Use the jobs command to view and manage shell jobs, control foreground and background tasks, and send signals to stop, kill, or restart processes by their PIDs or job numbers.