Learn how to use the Linux cut command for powerful text processing, including selecting character columns, ranges, specific fields with delimiters, complementing fields, changing output delimiters, and combining cut with other Unix tools such as grep, sed, and ps.
This article presents a comprehensive collection of Bash scripts that perform tasks such as verifying file consistency across servers, scheduled log cleaning, network traffic monitoring, numeric analysis in files, automated FTP downloads, interactive number games, Nginx 502 detection, variable assignments, bulk file renaming, IP address validation, and various system administration operations.
This guide explains the core concepts of Bash parameter expansion, walks through default values, conditional replacements, substring operations, deletions, and string substitutions, and demonstrates real‑world scripts for batch renaming, path handling, and simplifying user input.
This guide introduces ShellCheck, a static analysis tool for Linux shell scripts, outlines its key features, shows how to install it on various distributions or use it online, demonstrates command‑line usage with a practical example, and explains integration with editors like VSCode.
This article explains why long command‑line options improve shell script usability, compares the built‑in getopt utility with manual parsing, and provides complete Bash examples that demonstrate defining short and long flags, handling them, and printing the parsed results.
This guide explains how to capture command output and error messages in shell scripts, demonstrates basic output capture with $(), shows conditional handling using if statements, and provides a reusable run_command function—both simple and enhanced versions—to improve script robustness and maintainability.
This guide explains how to define, initialize, access, iterate, and modify Bash arrays, providing clear code examples and a practical case for checking installed packages, helping you write more efficient and readable shell scripts.
This comprehensive guide explains awk’s purpose, command syntax, script structure, built‑in variables, pattern matching, control flow, advanced I/O, and practical examples, enabling readers to harness awk for powerful text and data processing on Unix/Linux systems.
This guide introduces AWK’s powerful text‑processing capabilities on Unix/Linux, covering analysis, formatting, pattern matching, calculations, custom functions, flow control, and a practical IP‑counting example, all illustrated with clear command‑line snippets.
This guide explains how to use Bash's built‑in read command for interactive scripts, covering basic syntax, reading single or multiple values, prompting, timeouts, hidden input, default values, password handling, and multi‑line input with clear code examples.
This guide introduces awk as a powerful text‑processing tool, covering its basic syntax, field separators, pattern matching, arithmetic operations, built‑in variables, custom functions, control flow, and how to process both files and command output with clear code examples.
This guide explains how to use the Linux tput command to clear the screen, set foreground and background colors, apply text styles, query terminal dimensions, move the cursor, and create colorful text interfaces, providing practical code examples for each feature.
This guide explains how to use the powerful Linux tr command for character replacement, deletion, case conversion, whitespace compression, special‑character escaping, and reading character sets from files, providing clear examples and step‑by‑step code snippets for each use case.
This guide explains the Linux ps command’s syntax, common options, and advanced usage—showing how to list processes, filter by state, view resource usage, display process trees, sort by CPU or memory, monitor in real time, and combine with kill or pkill to manage processes effectively.
This guide explains how to use the Linux file command to identify single or multiple files, recognize text, binary, compressed, and image types, apply recursive and MIME‑output options, combine it with other utilities, and embed it in shell scripts for automation.
This guide explains how to install and use the Linux watch command for periodic command execution, system‑load monitoring, live log viewing, custom script scheduling, and several advanced options such as custom intervals, output redirection, screen clearing, timestamps, and display formatting.
This guide shows how to efficiently search and count matching lines in huge log files using grep, awk, and regular expressions, covering basic commands, combined conditions, port filtering, and IP address extraction for faster log analysis.
This tutorial explains several Bash techniques—including the test command, single‑bracket and double‑bracket syntaxes, and the stat utility—to reliably determine whether a file exists on a Linux system, complete with example code snippets and a reference table of test flags.
This guide explains rsync's fundamentals, usage in ssh and daemon modes, detailed configuration options, and how to combine it with inotify‑tools for real‑time, bidirectional file synchronization on Linux systems, including practical command examples and scripting tips.
This article presents a curated collection of eighteen practical Bash scripts that automate common Linux system tasks such as file consistency checks, scheduled log cleaning, network traffic monitoring, user management, firewall rules, and service health checks, providing ready‑to‑run examples for sysadmins.
This article presents a curated collection of eighteen Bash scripts that demonstrate how to automate common Linux system administration tasks such as file consistency checks, scheduled log cleaning, network traffic monitoring, numeric analysis, FTP operations, user management, firewall rules, and IP blocking, providing clear explanations and ready‑to‑run code examples.
This guide demonstrates how to use Bash to redirect standard input, output, and error streams to files, /dev/null, and even a TCP server, illustrating each technique with clear examples and step‑by‑step commands.
This article explains the purpose of the Bash built‑in exec command, demonstrates its effect on process trees through step‑by‑step experiments, and highlights important cautions when using exec in shell scripts.
This guide shows how to enhance Bash scripts with text‑based animations, local GUI notifications, parallel task execution, simple GUI dialogs, and styled terminal output using built‑in commands and utilities like printf, notify‑send, zenity, and tput.
This comprehensive guide introduces shell fundamentals, explains common shells, scripting conventions, variables, control structures, loops, functions, arrays, and provides practical scripts for tasks like backups, system monitoring, and LNMP deployment, all illustrated with clear Bash examples.
This article compiles a curated collection of 34 practical Bash scripts for Linux engineers, covering tasks such as number guessing games, network monitoring, user management, service control, log backup, and system health checks, providing ready‑to‑run code snippets to boost productivity and automate routine operations.
This comprehensive guide walks you through 40 practical Bash shell scripting examples—from a simple Hello World program to advanced file handling, conditionals, loops, functions, and system maintenance—showing how to write, execute, and debug scripts that automate everyday Linux tasks.
This comprehensive guide walks you through the fundamentals of Bash scripting on Linux, covering everything from a simple Hello World program and echo usage to loops, conditionals, functions, file manipulation, directory handling, and system maintenance, complete with clear code examples for each concept.
This article explains how attackers can exploit Linux file timestamps using shell commands and a custom Bash script to hide their activities, covering tools like touch, stat, ls, and detailed script steps for saving, modifying, and restoring timestamps to evade forensic detection.
This guide explains how to read and configure Linux environment variables, covering six methods—including export, editing ~/.bashrc, ~/.bash_profile, /etc/bashrc, /etc/profile, and /etc/environment—while detailing the loading order, user vs system scopes, and practical tips for managing PATH and custom variables.
This tutorial demonstrates how to build a lightweight Docker‑like container runtime using Bash by exploring Linux namespaces, cgroups, and overlayfs, providing step‑by‑step commands, code examples, and a full script that mimics core Docker functionalities for deeper operational understanding.
The article walks readers through building a minimal Docker‑like container runtime entirely in shell, explaining and demoing Linux namespaces, cgroups, and OverlayFS for isolation, resource control, and layered filesystems, and culminates in a concise Bocker script that implements core Docker commands.
This guide explores advanced Linux terminal techniques—including sending command output between terminal windows, efficiently reloading .bashrc, using alert aliases for long‑running tasks, leveraging the terminal as a calculator, and mastering subshells, command chaining, and brace expansion—to boost developer productivity.
This article shares practical Linux command techniques—including xargs, background execution, process monitoring, multitail, continuous ping logging, TCP state inspection, and SSH port forwarding—to help system administrators streamline tasks, improve script efficiency, and troubleshoot performance issues.
This article introduces the evolution of operations automation, highlights the power of concise shell scripts, and presents a 70‑page handbook covering fundamentals to advanced topics together with 100 ready‑to‑run script examples for Linux system administration and DevOps tasks.
This tutorial walks through essential Linux command-line techniques, showing how to create a reusable logmsg command, a timestamped backup utility, and a comprehensive Spring Boot administration script, complete with code examples, symbolic linking, permission handling, and execution guidance.
This article explains why the Linux find command is essential for backend developers and interviewees, demonstrates how to delete log files older than a year, and walks through seven practical find usages—including name patterns, file types, timestamps, size, permissions, ownership, and executing actions on matched files.
This guide shows how to monitor disk usage on a CentOS 7 server, collect periodic snapshots with iostat, sar and pidstat, troubleshoot atd scheduling issues, and finally use SystemTap to pinpoint the exact PID that writes to a specific file, providing complete scripts and command‑line steps.
This guide introduces Bash scripting fundamentals, covering variable declaration, printing with echo and printf, comments, user input, arrays, conditional statements, loops, functions, and tips for extending scripts with other languages, enabling readers to automate tasks on Unix-like systems.
This article presents seven ready‑to‑use Bash scripts that demonstrate parallel host querying, process statistics gathering, file renaming, directory management, log analysis, network request monitoring, and file size sorting, each with complete code and step‑by‑step explanations.
This article presents a collection of practical Linux shell commands—primarily using awk, grep, sort, uniq, netstat, and tcpdump—to count unique IPs, identify most‑visited pages, filter logs by time or URL, monitor connection states, and calculate traffic statistics for Apache or other web servers.
This guide presents a collection of practical Linux command‑line techniques—including file searching, batch extraction, text manipulation with sed, directory checks, disk usage monitoring, log analysis, firewall rules, and SNMP queries—to help system administrators automate routine tasks efficiently.
This article provides a extensive set of Bash scripts covering common Linux system administration tasks such as user management, service deployment, monitoring, backup, networking, and automation, offering ready-to-use code snippets and explanations for each operation.
This article compiles over forty everyday Bash programming mistakes that both beginners and seasoned users often overlook, explains why each pattern is problematic, and provides safe, portable alternatives with clear examples to improve script reliability and maintainability.
This guide explains what the Linux tee command does, how it’s installed, its basic syntax and options, and provides practical examples—including writing output to files, appending data, handling multiple files, piping to other commands, ignoring interrupts, hiding output, and using sudo—so readers can efficiently capture and process command‑line output.
This article explains why the Linux find command is essential for backend and operations engineers, walks through a common interview question about deleting year‑old log files, and then details seven practical find usages—including searching by name, type, timestamps, size, permissions, ownership, and executing commands on matches.
This guide explains the Linux tee utility, covering its purpose, installation verification, basic syntax, useful options, and seven practical examples that demonstrate writing to files, appending data, handling multiple outputs, ignoring interrupts, and combining tee with sudo for privileged writes.
This article explains how Python can replace or augment traditional Unix shell scripts for tasks like counting unique users, demonstrating the advantages of Python's readability, modularity, and extensive libraries while showing how to integrate Python scripts seamlessly into command‑line pipelines with tools such as sort, head, and tail.
This comprehensive guide introduces shell programming fundamentals, demonstrates how to write, execute, and manage scripts, explains variables, strings, parameters, arithmetic, control structures, functions, arrays, and file inclusion, and provides practical code examples for Linux environments.
This article compiles more than 40 everyday Bash programming mistakes that both beginners and veterans often overlook, explains why each example is wrong, and provides clear, corrected alternatives along with references to deeper resources, helping readers write more reliable shell scripts.
Learn seven practical uses of the Linux find command—from locating files by name, type, timestamps, size, permissions, and ownership to executing actions like deletion—complete with interview‑style examples and clear code snippets for mastering this essential system tool.
This guide explains how to use the Bash built‑in test command for evaluating numeric, string, and file conditions, shows practical examples with && and || chaining, and demonstrates alternative bracket syntax for robust shell scripting.
This article compiles a collection of practical Bash scripts for Linux engineers, covering interactive games, network connection checks, process management, system monitoring, file operations, user account handling, and automated backups, each presented with clear explanations and ready-to-use code examples.
This article presents nine practical Bash scripts covering DOS attack mitigation, email alerts, MySQL backups, Nginx log rotation and analysis, network traffic monitoring, server initialization, and disk usage checks across multiple hosts, each with ready-to-use code examples.
This guide explains why the command‑line interface is called a Shell, clarifies prompts and carriage returns, and walks through essential Bash features such as echo options, quoting rules, variable export, exec vs source, grouping, parameter expansion, arrays, arithmetic, redirection, conditional statements, loops, and control flow operators.
This article compiles 109 practical shell scripts covering a wide range of Linux automation tasks such as security, monitoring, backup, deployment, and system management, providing clear, copy‑ready code for hands‑on practice and interview preparation.
This article provides a comprehensive reference of essential Linux commands and procedures, covering system shutdown and reboot, hardware and environment inspection, file and directory management, user and permission handling, networking utilities, performance monitoring tools, and common text processing techniques for administrators and developers.
The article introduces the zx tool—a Node‑based scripting utility that streamlines command‑line automation by wrapping child_process, compares it with Bash and plain Node scripts, and demonstrates its advantages through practical code examples for tasks like batch media compression.
This guide outlines comprehensive shell scripting standards—including why they matter, core principles, file naming, encoding, line length, indentation, naming conventions, comment rules, error handling, and best‑practice patterns—to improve readability, maintainability, and consistency across Bash scripts in production environments.
This guide presents a collection of practical Linux command-line snippets—including file searching, batch extraction, text processing with sed, directory checks, disk usage monitoring, log analysis, firewall rules, and SNMP configuration—to help system administrators automate routine tasks efficiently.
This article introduces the role of shell scripts in automating system operations, presents a free 70‑page practical handbook covering fundamentals to advanced topics, and offers 100 ready‑to‑run script examples ranging from basic hello‑world to complex monitoring and deployment tasks, helping readers quickly boost their scripting skills.
This tutorial walks Java developers through the fundamentals of Linux shell scripting, covering how to create and run scripts, check and set the default shell, manage permissions, define and manipulate variables, and implement flow‑control constructs such as if/else, case, for, and while loops with practical code examples.
This article explains why traditional cloud storage can be slow or limited, introduces the free command‑line tool transfer.sh, lists its key features, and provides step‑by‑step examples for uploading, downloading, encrypting, and automating file transfers across platforms.
Jaromil’s 13‑character Linux fork bomb demonstrates how a tiny Bash function can recursively spawn processes, exhausting system resources and causing a denial‑of‑service crash, while the article explains its mechanics, shows a live cloud‑VM demo, and provides practical mitigation using ulimit and security limits.
This guide explains how to use the Linux find command to locate files by name, size, time, permissions, owner or group, provides a full list of options, and includes practical examples demonstrating common search patterns and actions.
This guide demonstrates three practical methods for bulk renaming files on Linux: using sed for in‑place text replacement, applying Bash variable substring manipulation, and changing file extensions with parameter expansion, each illustrated with complete command‑line examples.
This guide shows step‑by‑step Linux techniques—including a powerful Find‑pipeline and the dupeGuru tool—to locate and list duplicate files by size and MD5, with full command explanations and handling of Windows line‑ending issues.
This article curates a collection of powerful command-line utilities—including ag, tig, mycli, jq, shellcheck, fzf, PathPicker, htop, glances, axel, sz/rz, cloc, tmux, script, and multitail—explaining their core features and how they can replace or enhance traditional tools for developers and system operators.
This tutorial explains how to use the Linux date command to show the current time, format dates in various ways, query past or future dates, customize output with format specifiers, set the system clock, and incorporate date values into shell scripts.
This guide explains how to use and name shell variables, manipulate strings, create and run Bash scripts, manage environment variables, perform arithmetic and relational operations, read user input, and handle common file‑system tasks, providing clear examples and command‑line snippets for each topic.
This article outlines practical shell‑script guidelines for automating system and application operations, covering script header conventions, formatting, error handling, safe use of commands, variable handling, file packaging, pipeline restrictions, concurrency locks, logging, and risk‑mitigation strategies to make automation both efficient and secure.
This article explains why a simple Bash loop may output zero when trying to sum the second column of a text file, demonstrates three different line‑by‑line approaches, shows common pitfalls such as pipeline subshells and whitespace handling, and provides correct solutions with shellcheck recommendations.
This article provides a comprehensive guide to Bash scripting, covering if/elif/else conditionals, case statements, four types of loops (for, while, until, select), signal trapping with trap, useful one‑liners for randomness and colored output, and several fun scripts such as a multiplication table, colored triangle, and chessboard.
This article provides a comprehensive guide to Bash scripting, covering conditional statements (if/elif/else), case selections, various loop constructs (for, while, until, select), loop control commands, parameter shifting, signal trapping with trap, and includes numerous practical code examples with detailed analysis.
This guide provides a comprehensive walkthrough of Bash scripting fundamentals, covering conditional statements, various loop constructs, signal handling with trap, and a collection of useful one‑line scripts and visual examples for everyday tasks.
This article compiles a comprehensive set of Bash scripts that demonstrate how to verify file consistency across servers, schedule log cleaning, monitor network traffic, count numeric characters in files, manage users and passwords, automate firewall rules, and perform various other Linux system administration tasks, providing ready-to-use code snippets for each scenario.
This article provides a detailed Bash scripting tutorial covering conditional statements (if/elif/else, case), various loop constructs (for, while, until, select), control commands (break, continue, shift), signal handling with trap, and several practical example scripts such as a multiplication table, colored triangle, and chessboard pattern.
This comprehensive guide introduces awk as a powerful Linux text‑analysis tool, explains its underlying record‑field model, demonstrates practical one‑liners and scripts for reporting, filtering, formatting, file splitting, and shows advanced features like built‑in variables, conditionals, arrays, and string functions.
This guide introduces Bash shell fundamentals, covering script shebangs, execution methods, echo and printf usage, color output, variable handling, PATH manipulation, arithmetic operations, and conditional expressions, providing practical examples for Linux command‑line users.
This article explains common awk built‑in variables such as OFS, NR, and NF, demonstrates practical awk one‑liners for extracting and formatting /etc/passwd data, and shows how to use netstat (and ss) together with awk to monitor network connection states on a Linux system.
This article explains how to use the Linux export command to set and view environment variables, demonstrates common options such as listing all exports, exporting specific variables, exporting functions, and shows how to persist settings in shell configuration files, providing practical examples for beginners.
This guide walks you through creating a .sh Bash script, adding a simple “Hello World” program, granting execute permission with chmod, and running it directly or via sh/bash, plus a practical backup script example that archives /var/log using tar.
This guide explains how to use the Linux basename utility to strip directory paths and suffixes from filenames, covering its basic syntax, useful options like -z, -a, and -s, handling multiple files, removing extensions, and embedding it in shell scripts.
This guide explains how to create, test, and apply boolean-like variables in Bash, covering numeric (0/1) and string (true/false) representations, conditional checks, and practical examples for cron jobs and backup scripts on Linux/Unix systems.
This guide introduces a minimal, safe Bash script template, explains why Bash is still essential for backend tasks, and walks through best‑practice features such as strict error handling, portable shebang, colorized messaging, parameter parsing, cleanup traps, and portability across macOS and various Linux distributions.
This article provides an in‑depth tutorial on using the Linux logrotate utility, covering default configuration files, command‑line options, example configurations for services like Nginx, PHP‑FPM, Tomcat, custom Bash and Python rotation scripts, troubleshooting tips, and how to adjust cron scheduling for automated log rotation.
This guide explains how to execute external shell scripts, import their functions and variables using source, dot, or sh commands, compares their behaviors, and provides practical patterns—including case dispatch and a generic function‑call template—to enable reliable script reuse in Linux environments.
This guide explains how the Linux tee command reads from standard input and simultaneously writes to both a file and the screen, providing seven detailed examples that cover basic usage, writing to multiple files, silent output, appending, sudo integration, piping between commands, and using tee within vim.
Learn step-by-step how to install the msmtp email client, configure mutt for sending mail, use the free command to monitor Linux memory and swap usage, script automated monitoring and alerting, and schedule these tasks with cron for continuous system health checks.
This guide consolidates practical conventions for writing clean, maintainable shell scripts, covering shebang usage, commenting, parameter validation, variable handling, indentation, naming, encoding, efficiency tricks, and static analysis with ShellCheck.
This guide demonstrates how to use AWK’s sub, gsub, and pattern‑matching features to delete blank lines, trim whitespace, reverse file order, add line numbers, count or filter specific strings, replace text, and combine AWK with other Linux utilities for everyday text‑processing tasks.
This guide walks you through Linux command‑line tools—tr, awk, sed, and even Python—to efficiently convert text case, handle whole‑file transformations, capitalize only first letters, and ensure proper title‑case formatting for scripts and shell pipelines.
A concise collection of Linux command-line one‑liners demonstrates how to extract IPv4 addresses, disk usage, user information, permissions, and pattern matches using regular expressions and tools like ifconfig, df, cat, cut, sort, and egrep.
This article explains how Linux command‑line pipelines work, highlights the limitations of traditional shell scripts, and demonstrates how a concise Python script can replace them for counting unique users in log files while remaining easy to read, reusable, and powerful.
This guide presents practical techniques for creating reliable Bash scripts, covering syntax checking, automatic exit on errors, execution tracing, undefined‑variable detection, pipe‑fail handling, readonly variables, default values, command chaining, and function usage, with concrete code examples and tool recommendations.
This guide introduces the powerful Unix text‑processing trio—grep, sed, and awk—explaining their syntax, common options, and real‑world examples for searching, filtering, replacing, and scripting, enabling readers to handle data efficiently from the command line.
This article compiles practical shell‑script coding standards—covering shebang usage, commenting, parameter validation, variable handling, indentation, naming, encoding, logging, security, modular design, parallel execution, and static analysis with shellcheck—to help developers write readable, maintainable, and performant Bash scripts.
This comprehensive guide covers fundamental Linux commands such as ls and cat, user and group management, package handling with RPM and yum, process monitoring tools, file searching utilities, scheduled task creation with at and crontab, and automating interactions using Expect, providing clear examples and code snippets for each topic.
This guide introduces the core concepts of the Unix sed command, covering its basic syntax, common options, address ranges, editing commands, substitution patterns, useful flags, and practical one‑liners for text manipulation and system administration tasks.
This guide explains why Linux is essential for software testers, outlines how to build test environments, use key commands like tail, grep, top, and vmstat for log analysis and performance monitoring, and offers tips for deeper Linux learning and interview preparation.
