
Already know some of this? A 2-minute test skips the lessons you know.
Take the placement testA free 57-lesson course built from Code Synth's 10h 11m of YouTube playlist. 7 days at 90 minutes a day, with study notes and a quiz in every lesson. A 2-minute placement test skips what you already know.
Taught by Code Synth on YouTube. Videos play in YouTube's own player, so the creator keeps every view.
Understand what sed is, how it processes text line by line using a pattern space buffer, and its default read-edit-output workflow without modifying the original file.
Use core sed commands (print, delete, substitute) and essential options (-n to suppress default output, -i for in-place editing) with practical examples.
Target specific lines using address ranges (M,N), step addressing (M~N), and regular expression patterns (/pattern/) with negation (!) for selective editing.
Apply regex metacharacters (., *, +), anchors (^, $), and extended regex features (-E flag) for powerful pattern matching in sed scripts.
Utilize character classes (e.g., [a-z], [0-9]), capture groups with parentheses, and backreferences (e.g., 1, 2) to perform complex search-and-replace operations.
Manipulate multiple lines using the hold space commands: copy to hold (h/H), append to hold (H), get from hold (g/G), exchange (x), and practical line-swapping example.
Write a bash function that reads a file line by line, validates that the first field contains only alphabets and the second field is an 8-character hexadecimal code, and prints the filename with PASS or FAIL.
Construct a pipeline to list all processes, sort numerically by CPU time (10th column) descending, exclude root-owned processes, extract the top PID, and kill it.
Understand what command line utilities are and learn to use the find command with options like -name, -type, -atime, -mtime, -ctime, -regex, and -print to locate files based on various criteria.
Differentiate between archiving (tar) and compression (gzip, bzip2, xz), understand tarballs as combined archive+compression, and identify key tar options (c, x, v, f, z, j, J).
Identify script components (shebang, comments, commands), distinguish between sourcing (source/script.sh) and executing (./script.sh) scripts, and explain the impact on shell environment and variable persistence.
Apply integer comparison operators (-eq, -ne, -gt, -lt, -ge, -le), boolean logic (!, -o, -a), and string tests (-z, -n, =, !=) within script conditional statements.
Learner will be able to declare shell variables without spaces, print their values using the $ prefix, distinguish single vs double quotes, and unset variables to delete them.
Learner will be able to append text to variable output using curly braces, store command output in a variable using backticks or $(), and extract substrings using zero-based index slicing.
Learner will be able to create indexed arrays with `declare -a`, assign values at specific indices (including sparse indices), print all values or keys, and determine array length.
Learner will be able to create associative arrays with `declare -A`, set key-value pairs, retrieve keys and values (noting reverse insertion order), and iterate over entries using a for-loop.
Learner will be able to perform pattern substitution (first match, global match, prefix/suffix removal) using `${var/pattern/replace}`, `${var//pattern/replace}`, `${var#pattern}`, `${var##pattern}`, `${var%pattern}`, `${var%%pattern}` and convert case with `${var,}`, `${var,,}`, `${var^}`, `${var^^}`.
Identify correct SSH key file permissions (chmod 600) to resolve 'Permission denied' errors when connecting to a remote VM.
Construct a regular expression to match the email field in a JSON file, handling quotes, whitespace, and non-empty values.
Write regular expressions to match Class A (10.0.0.0/8) and Class C (192.168.0.0/16) IPv4 address ranges with correct octet validation (0-255).
Learner will be able to predict the resulting directory tree and identify command failures when using mkdir -p and touch with nested paths.
Understand the purpose of regular expressions for pattern-based text filtering and distinguish between basic (grep) and extended (egrep) regex engines.
Apply dot, star, and anchor metacharacters to filter a sample names file and interpret highlighted matches.
Filter lines using POSIX classes ([:digit:], [:alpha:], etc.) and invert matches with the -v flag to select non-matching lines.
Capture sub-patterns with parentheses and reuse them via back-references (1, 2) to match repeated structures like roll numbers.
Use cut with delimiter (-d) and field (-f) or character (-c) options to extract specific columns or character ranges from each line.
Use semicolons, &&, and || to run multiple commands sequentially, conditionally on success, or conditionally on failure.
Redirect standard output, standard error, and standard input using >, >>, 2>, <, and pipes; combine streams with 2>&1 and tee for intermediate storage.
Create subshells with parentheses, read $BASH_SUBSHELL and $?, use exit codes (0–255), and inspect shell options with echo $-.
Identify OS with lsb_release -a, compare RPM and DEB package managers, and parse package naming conventions for both formats.
Classify packages by priority (required, important, standard, optional, extra), verify integrity with md5sum/sha256sum, and search/install with apt-cache and apt-get.
Create the sc201 workspace, use brace expansion to generate a nested directory structure (departments, teams, project files), and verify the solution with synchro.
Write an executable script.sh that uses diff -u for unified differences and comm -12 with sort to list common lines between file1.txt and file2.txt.
Create a script that runs nslookup on given websites, tests each returned IP address for connectivity, and echoes 'site yes' or 'site no' accordingly.
Build a deep project directory tree (src, docs, bin, modules, include, lib) using mkdir -p and create .c/.h source files at specified paths with touch.
Create hard links in bin/, symbolic links in project/ and module2/, then apply chmod 755 to executables, 700 to directories, and 644 to header files before final synchro evaluation.
Understand the difference between hard links and symbolic (soft) links, their limitations, and how to create them using the ln command.
Identify common terminal-based editors (ed, nano, vi, emacs) and GUI editors, and recognize which are used for scripting and system administration.
Learner will navigate the filesystem using pwd, cd (including relative/absolute paths, .., ~, -), and list contents with ls using -a, -l, -h flags.
Learner will create and timestamp files with touch, write and overwrite files with cat redirection, and edit files using basic vi commands (i, Esc, :wq).
Learner will move and rename files/directories with mv and copy them with cp, using relative paths like ..
Learner will count lines, words, and characters with wc flags (-l, -w, -c) and sort file contents alphabetically with sort (including -c check and -o output).
Learner will change file permissions using chmod symbolic notation (u/g/o, +/-/=, r/w/x) for user, group, and others.
Distinguish between kernel (hardware abstraction layer), shell (command interpreter), and terminal (wrapper program running the shell), and explain their interaction hierarchy.
Identify major Linux distributions, trace Unix/Linux lineage (Unix → BSD/macOS, Linux kernel), and recall core Unix philosophies: 'everything is a file', multi-user, multi-tasking, and root privileges.
Map the purpose of standard top-level directories (/bin, /sbin, /lib, /dev, /home, /usr, /tmp, /etc, /root) and differentiate user vs system binary locations.
Decode the 10-character permission string (type, owner/group/other rwx), link count, owner, group, size, timestamp, and name from `ls -l` output to identify file type and access rights.
Use pwd, ls (with -a, -l, wildcards * and ?), cd (absolute/relative), ps, whoami, and clear to navigate, list processes, identify the current user, and manage the terminal view.