This article presents a comprehensive list of essential Linux commands, organized into categories such as online queries, file operations, content viewing, compression, system information, user management, networking, disk handling, permissions, and performance monitoring, each illustrated with reference images.
From the moment a user types a command in the shell to the final exit of the program, this article walks through Linux’s execution pipeline—including shell command parsing, fork, execve, kernel loading via load_elf_binary, the dynamic linker’s role, and the glibc startup sequence—illustrated with detailed diagrams and code snippets.
This article shares concise, easy-to-understand shell command techniques—using grep, sed, awk, tr, and vi—to efficiently delete empty lines from log files, highlighting each tool's syntax, options, and practical usage for embedded software developers.
This article presents a concise, beginner‑friendly list of the most useful Linux command‑line utilities, explaining each command’s purpose and syntax to help newcomers transition from Windows to Linux and become comfortable with terminal operations.
This comprehensive guide explores Linux's four main components—kernel, shell, filesystem, and applications—detailing kernel architecture, memory and process management, VFS, device drivers, networking, file types, directory structures, mounting, and practical commands for managing partitions and links.
The article explains how to use the Linux commands ifconfig, ifup/ifdown, and route for querying and modifying network interfaces, IP addresses, subnet masks, MTU values, and routing tables, providing example usages and practical tips for immediate effect.
This guide explains Linux environment variables, covering system‑wide and user‑specific permanent settings, temporary shell variables, common variables like PATH and HOME, and essential commands for viewing, modifying, and managing them effectively.
A concise reference of the most useful Linux shell commands—from file searching and process management to networking and file compression—explains syntax, common options, and practical examples to help developers interact efficiently with Linux servers.
This guide walks through preparing the Linux environment on Kubernetes master and node machines, creating a bare Git repository, configuring SSH access, cloning the repository, and demonstrating core Git commands such as add, commit, status, diff, and push to a remote server.
This article provides a comprehensive overview of Linux's core components—including the kernel, memory and process management, virtual file system, device drivers, network stack, shell variants, file types, directory hierarchy, partitioning, mounting, and essential command‑line tools—while illustrating each concept with diagrams and code examples.
This guide provides system administrators with a step‑by‑step checklist to audit and harden Linux operating systems, covering account management, password policies, service restrictions, filesystem permissions, logging configuration, and practical command examples for comprehensive security compliance.
A comprehensive reference of over two hundred Linux command‑line utilities, grouped by function such as file management, system monitoring, networking, user administration, and process control, each with concise English descriptions to help beginners and seasoned administrators quickly find the right tool for any task.
This guide explains why standard rm fails on files with special characters or leading dashes and provides six reliable techniques—including using a path prefix, the "--" separator, quoting, escaping, inode deletion, and wildcards—to safely remove such files on Linux systems.
This article introduces several essential Linux commands—including crypt (via mcrypt), various kill utilities, shred for secure deletion, zombie process identification, the at scheduler, and daemon management—explaining their purposes, usage examples, and relevant options for system administrators.
This article explains the types and default actions of Linux signals, distinguishes between standard and real‑time signals, and demonstrates how to use the kill and trap commands with practical shell script examples for signal handling.
This guide introduces ten fundamental Linux commands—pgrep, pstree, bc, split, nl, mkfifo, ldd, col, xmlwf, and lsof—explaining their purposes, typical usage examples, and how they help developers and system administrators efficiently manage processes, files, and system resources.
This guide explains how to list available shells, identify the current login shell, and use the chsh command to switch the default shell on a Linux system—covering changes to zsh or bash, verification steps, and accessing chsh help options.
This article provides a comprehensive guide to Shell scripting, covering variable definition, arithmetic, string manipulation, arrays, quoting rules, control structures, functions, command‑line parsing, debugging, common text‑processing tools, file attribute changes, file management, user and group administration, disk utilities, and includes practical code examples for each topic.
This comprehensive tutorial walks you through why Linux matters, how to install VMware, create and configure a CentOS VM, set up networking, use Xshell, master essential commands, manage users, install software via source, RPM or YUM, and write functional Bash scripts with practical examples.
This comprehensive cheat‑sheet covers essential Linux commands for viewing system information, managing files and directories, handling users and groups, controlling permissions, mounting filesystems, performing backups, and using package managers like RPM, YUM, DEB and APT, plus networking and CD/DVD utilities.
This article provides a comprehensive reference of essential Linux system commands covering system information, date and time management, shutdown/reboot, file and directory operations, searching, mounting, disk usage, user and group management, permissions, special attributes, compression, package handling, network utilities, and backup techniques, all presented with concise examples for quick learning.
This guide walks through recovering lost Grafana data in a Kubernetes cluster by using low‑level shell scripts, the grafana‑backup‑tool, Docker images, GitHub Actions, and Podman deployments, covering export/import commands, component selection, and handling provisioned dashboards.
This guide explains how to read, configure, and persist Linux environment variables—especially PATH—using export commands, user‑level files like ~/.bashrc and ~/.profile, and system‑wide files such as /etc/profile, /etc/bashrc, and /etc/environment, while also detailing the loading order and testing techniques.
This article explains the fundamentals of Linux pipes and file redirection, covering their definitions, how they work as inter‑process communication mechanisms, how to create and use them in C with pipe(), dup2() and fork(), and how to redirect standard streams using freopen(), all illustrated with clear code snippets and diagrams.
This tutorial explains how Jenkins can be used to run simple shell commands such as retrieving host information and how to automate bulk host‑key distribution with a custom script, illustrating the CI platform’s integration with version control and its ability to execute OS‑level operations.
This guide compiles practical Linux shell commands and scripts for tasks such as locating and moving files, batch extraction, text manipulation with sed, directory checks, disk‑space monitoring with email alerts, log analysis, firewall rules, SNMP queries, and more, helping sysadmins automate routine operations efficiently.
This guide compiles the most frequently used Linux commands for file navigation, content viewing, searching, permission handling, text processing, compression, system shutdown, and process management, providing clear syntax examples and practical tips to boost operational efficiency for system administrators.
This guide explains the different types of brackets used in Bash—parentheses, square brackets, double brackets, and braces—covering their syntax, typical use cases such as command grouping, arithmetic evaluation, array handling, test expressions, parameter expansion, and pattern substitution with clear examples.
This guide explores several powerful yet intimidating Linux commands—including crypt, kill, shred, zombie process detection, at midnight scheduling, and daemon management—explaining their purposes, usage nuances, and safety considerations for system administrators and power users.
This guide provides a concise, alphabetically ordered reference of 35 core Linux (and macOS) terminal commands, complete with explanations, practical examples, and usage tips to help newcomers quickly become comfortable navigating and managing a Unix-like system.
This guide compiles dozens of practical Linux shell commands for deleting zero‑byte files, inspecting processes, checking CPU, memory, disk usage, and more, plus a collection of useful regular expressions for matching Chinese characters, emails, URLs, IPs, and other patterns.
This guide explains how to configure Linux environment variables—especially PATH—using export commands, editing user and system profile files, and demonstrates the exact order in which Ubuntu loads these files, helping you avoid conflicts and ensure persistent settings.
This guide shows how to create and use a Bash script called tf that leverages the tree command to display directory structures, supports keyword searching, and explains the color codes used to differentiate file types in the output.
This guide walks through installing Zsh on Ubuntu 20.04, setting it as the default shell, configuring initial options, and reverting to Bash, providing step‑by‑step commands and screenshots for each stage.
This guide presents ten practical Linux system‑administration tricks—from unmounting a stuck DVD drive and resetting a frozen console to using screen for collaborative debugging, recovering a lost root password, creating SSH backdoors, tunneling VNC, measuring bandwidth, and automating host‑file generation—helping admins work faster and smarter.
This guide demonstrates how to extract a macOS Chrome user's browsing URLs and timestamps from the History SQLite database, save them to a text file, and automatically email the file daily using Python scripts, a shell wrapper, and a crontab scheduled task.
This article presents a curated list of essential command‑line interface (CLI) tools—including shells, fuzzy finders, file search utilities, system monitors, version managers, and more—explaining their key features, typical use cases, and where to download them, helping developers boost productivity in the terminal.
The article examines the 2020 Beijing points‑based household registration dataset, showing how to download the CSV, use shell commands like awk, sort, uniq, and grep to extract score, company, surname, given‑name, and age distributions, and highlights the top companies and common surnames.
This article presents a curated list of essential command‑line tools—from modern shells and version managers to system monitors and database clients—detailing their key features, usage benefits, and download links, helping developers boost productivity across diverse programming tasks.
This guide provides a comprehensive overview of essential Linux command‑line utilities for text manipulation—including find, grep, xargs, sort, uniq, tr, cut, paste, wc, sed, and awk—detailing common options, practical examples, and advanced techniques for searching, filtering, transforming, and processing files efficiently.
This article compiles a comprehensive set of Linux shell commands for deleting zero‑byte files, inspecting processes, sorting by memory or CPU usage, checking URLs, network connections, system load, disk space, logs, and includes a handy collection of common regular expressions for text processing.
Sampler is a lightweight tool that runs shell commands, visualizes their output, and can trigger alerts; configured via simple YAML, it works on macOS, Linux and Windows, supports various components such as runcharts, sparklines, gauges, and interactive shells for monitoring databases, queues and system metrics.
This article provides a detailed, English‑translated reference of essential Linux command‑line tools covering file management, content viewing, compression, system information, networking, user administration, permissions, process control, and system monitoring, useful for both beginners and experienced administrators.
This comprehensive guide breaks down the four main parts of a Linux system—kernel, shell, filesystem and applications—detailing kernel subsystems such as memory and process management, shell variants, file types, directory hierarchy, partition handling, VFS, mounting procedures, link types and essential command‑line tools, while also touching on application bundles and kernel parameter tuning.
This article provides a comprehensive overview of Linux system architecture, covering the kernel, memory and process management, virtual file system, device drivers, networking, shell types, filesystem hierarchy, partitioning, mounting, and common commands, offering a solid foundation for understanding Linux fundamentals.
This article compiles a comprehensive list of frequently used Linux commands, revealing the full meanings behind their abbreviations and explaining what each command does, providing a handy reference for developers, system administrators, and anyone working with Unix-like environments.
This guide walks through the most common Linux shell tools for text processing—including find, grep, xargs, sort, uniq, tr, cut, paste, wc, sed, and awk—explaining their core options, practical examples, and how to combine them for powerful command‑line workflows.
This article introduces a collection of essential Linux/macOS command‑line tools—such as find, grep, awk, sed, and others—explaining their key options and demonstrating practical examples like log analysis, database URL correction, and bulk file processing to dramatically improve everyday developer productivity.
The article explains why Linux’s free command reports far higher used memory than the RSS values shown by ps aux, by breaking down buffers, cache, slab allocations, page tables and shared libraries, and provides shell scripts to calculate each component.
This article walks through ten common Linux shell interview questions, covering script interruption, file header removal, line length checking, viewing non‑printing characters, directory permissions, process states, cut usage, cmp vs diff, echo vs ls, and a brief explanation of inodes.
This article presents ten common Linux shell interview questions, explains how to interrupt scripts, manipulate files with sed, check line lengths, view non‑printable characters, set directory permissions, understand process states, and use commands like cut, cmp, diff, echo, and inode.
This article presents ten common Linux shell interview questions, providing clear explanations, command-line solutions, code examples, and step‑by‑step guidance on script termination, file header removal, line length checking, non‑printable character display, directory permissions, process states, cut, cmp vs diff, echo vs ls, and inode basics.
This guide explores Bash's built‑in history command, revealing hidden features like event designators, string search, relative indexing, and quick substitution to boost shell productivity.
This article explains how to implement reliable screen‑capture during Android black‑box testing by leveraging ActivityController, custom Shell services, IProcessObserver, and optional root‑level getevent commands, providing code examples and an integrated workflow for detecting page changes and handling crashes.
This article provides a comprehensive overview of Linux’s core architecture, detailing the kernel, shell, memory and process management, virtual file system, various file system types, directory structures, partitioning, mounting procedures, and link mechanisms, offering readers a solid foundation for mastering Linux systems.
This comprehensive guide explores Linux's core components—including the kernel, shell, memory and process management, file systems, device drivers, network interfaces, mounting mechanisms, and link types—providing clear explanations, diagrams, and command examples for anyone learning operating system fundamentals.
This tutorial shows how to use standard Unix shell tools such as grep, cut, sort, uniq, awk, and join to extract insights—top companies, most common surnames, popular given names, age distribution, and hometown statistics—from a JSON dataset of over 6,000 Beijing residency applicants.
This tutorial shows Python developers how to configure the interpreter so that a short "peace mantra" is automatically printed before any script or interactive session runs, using usercustomize.py, PYTHONSTARTUP, and simple shell setup to help keep bugs at bay.
This guide explains how the Linux ps command works, details its most useful options for listing, filtering, sorting, and formatting process information, and shows how to combine it with tools like watch, less, and pstree for real‑time and hierarchical views.
This guide explains how to use the Linux ps command to inspect and control processes, covering basic usage, common options, output formatting, filtering by user, CPU or memory usage, displaying process trees, security information, and real‑time monitoring with watch.
This guide explains the drawbacks of fixed positional parameters in shell scripts, demonstrates simple examples, and introduces the getopts utility to handle named options, optional arguments, and error suppression, enabling more flexible, readable, and maintainable command-line interfaces.
This article introduces macOS Terminal as the bridge between the kernel and the user interface, explains how to open it, covers fundamental concepts such as commands, paths, and file operations, and provides a collection of practical commands—from simple echoes to disk management and Homebrew installation—while warning about risky operations and offering advanced customization tips.
The article evaluates MySQL Shell 8.0.21's new logical backup and restore method—featuring ZSTD compression, chunked parallel export, and parallel LOAD DATA import—against mysqldump, mysqlpump, and mydumper, presenting benchmark results, analysis, and practical command examples.
This guide explains the Linux cut command, covering its basic syntax, essential options such as field, delimiter, byte and character extraction, and advanced features like complement and custom output delimiters, with step‑by‑step examples and notes on limitations.
This guide introduces ten useful Linux command‑line tools—including pgrep, pstree, bc, split, nl, mkfifo, ldd, col, xmlwf, and lsof—explaining their purpose, typical usage patterns, and providing concrete command‑line examples to help users manage processes, files, and system information efficiently.
This article presents ten common Linux shell interview questions, each followed by clear explanations and exact command‑line solutions—including script termination, file header removal, line length checking, non‑printable character display, directory permissions, process states, cut usage, cmp vs diff, echo vs ls, and a brief overview of inodes.
This guide walks you through creating sample files, using the Linux diff command to detect differences, interpreting its output symbols, handling case‑sensitivity, ignoring whitespace, and swapping file order, all illustrated with step‑by‑step commands and screenshots.
This guide walks you through the Linux ps command, covering basic usage, common options for listing all processes, filtering by user, CPU or memory usage, process name, PID, threads, tree view, security details, root‑specific formatting, and real‑time monitoring with watch.
This article demonstrates how to list fail‑list files on Linux, extract user names via shell string trimming, capture the output in a Jenkins pipeline, convert it into a Groovy array, and send individualized email notifications with the corresponding files attached.
This guide explains how to prevent Jenkins shell steps from aborting on errors by using the +e option, appending || true, or custom failure handling commands, and provides four concrete examples with test results to illustrate each method.
This guide walks you through installing the Z shell (zsh) on Linux, adding the popular Oh‑My‑zsh framework, and configuring key plugins such as syntax highlighting, autosuggestions, and fzf to streamline command‑line work and improve productivity.
This guide explains why long‑running programs stop when a terminal closes, introduces the nohup command to ignore hang‑up signals, and provides step‑by‑step examples for running, redirecting output, backgrounding, chaining multiple commands, and terminating nohup‑started processes on Linux.
This article introduces the howdoi tool—a lightweight command‑line Q&A utility that lets Linux users ask natural‑language questions and instantly receive concise command tutorials, installation steps, flag options, and example usages, all sourced from AskUbuntu.
This guide explains the fundamentals of Linux shells—including common shell types, variable classifications, environment and user-defined variables, the order in which configuration files are loaded for interactive and login sessions, and how to write reliable conditional tests in shell scripts.
This guide explains how to use the Linux grep command with common options and regular‑expression patterns, providing step‑by‑step examples that demonstrate counting matches, case‑insensitive searches, inverse matches, anchoring, character classes, and quantifiers.
This guide explains the powerful Linux grep command, its syntax and common options, and provides step‑by‑step examples demonstrating how to use regular expressions for precise text searching and filtering in shell environments.
The article explains how MySQL Shell 8.0.17+ can be extended using JavaScript or Python to build reusable reports and plugins, describes the directory layout, provides a complete example of registering a report and a plugin that list tables without primary keys, and shows how to invoke them via \show, \watch or direct function calls.
This guide shows how to use Bash while and until loops to repeatedly run a ping command, pause between attempts, and stop automatically once the network connection succeeds, including a quick trick to repeat the previous command until it succeeds.
This guide shows how to locate every .git directory within a few levels, trim the paths, and run git pull on each repository using a single pipeline command that can also be saved as a convenient shell alias.
This guide shows how to create a lightweight, recursive file‑search script for Linux that mimics the Windows Everything tool, explains each part of the shell code, and demonstrates how to run it, enable case‑sensitivity, search specific paths, and bind it to a custom alias.
This guide explains how to perform time addition, subtraction, and difference calculations in shell scripts by converting dates to timestamps, manipulating seconds, and converting results back to readable formats, complete with practical examples and essential Bash arithmetic operators.
This tutorial explains the Linux cut command, covering its syntax, key options such as -f, -d, -b, -c, --complement and --output-delimiter, and provides numerous real‑world examples for extracting fields, characters, and bytes from text files and combining cut with other Unix utilities.
Discover ten handy but often overlooked Linux commands—pgrep, pstree, bc, split, nl, mkfifo, ldd, col, xmlwf, and lsof—each explained with clear descriptions and practical example usages to boost your command‑line efficiency.
This article explains four Python techniques—os.system, os.popen, the commands module, and subprocess—for running shell commands, comparing their ability to capture output, return status, and recommending subprocess as the most flexible modern solution.
This guide explains how to use Zabbix's auto‑discovery feature to automatically find Redis instances on a server, create shell or Python scripts for port detection, configure Zabbix agent keys, set up server‑side templates, discovery rules, item prototypes, graphs, and triggers, and finally apply the template to monitored hosts.
Learn how to quickly locate, filter, and rename files on Linux using concise ls, find, du, and rename commands, plus practical examples that cut down search time, reveal the largest items, count directory contents, and automate batch renaming.
This article introduces ten handy but often overlooked Linux commands—pgrep, pstree, bc, split, nl, mkfifo, ldd, col, xmlwf, and lsof—explaining their purpose, typical use cases, and providing concrete shell examples for each.
This guide walks you through installing the ‘motivate’ and ‘fortune’ command‑line tools on Debian‑based and RPM‑based Linux distributions, configuring them to display random motivational or witty quotes each time you open a terminal, and shows how to keep them updated.
This article humorously compiles a variety of command‑line tricks—from simple process killing to Docker container shutdown and even a Python one‑liner—to force‑quit Vim, while also offering tongue‑in‑cheek “violent” and “Zen” approaches for developers who struggle with the editor's steep learning curve.
This article provides concise explanations and command examples for common Linux interview topics, covering GPL and free software, buffer vs cache, runlevels, boot sequence, link types, shell exit status, history timestamps, log analysis, port forwarding, load troubleshooting, fstab fields, packaging, password generation, TCP state, and MySQL root recovery.
This article explains the Linux wait command, how it monitors and synchronizes processes by returning exit statuses, and provides step‑by‑step script examples that demonstrate waiting for background jobs versus running them without wait, highlighting key differences and practical usage.
A detailed performance comparison shows that using input redirection to load a huge MySQL dump is roughly three times faster than piping the file through cat, because the redirection reads the data only once while the pipe incurs extra reads and a context switch, as demonstrated with SystemTap tracing.
This guide introduces the powerful Linux find command, explaining its syntax, common options such as -name, -type, -perm, and actions like -print, -exec, and -ok, and provides numerous practical examples for searching files by name, path, permissions, type, size, time, and executing commands on matches.
This article explains how to replace cumbersome Python‑Plotly visualizations of performance test logs with a lightweight Groovy solution that generates plain‑text bar charts directly in the shell or email, using Unicode block characters and a bucket‑based median algorithm.
This guide explains how to use Unix shell for‑loops and the find command to batch‑process files, covering basic syntax, practical ImageMagick examples, loop restrictions, variations across shells, and advanced find‑exec techniques for efficient automation.
This article presents a comprehensive collection of essential Linux command-line tools, covering file and directory manipulation, content viewing, compression, system monitoring, user management, network operations, disk and filesystem handling, permissions, process control, and shutdown/reboot procedures, each illustrated with reference images.
This article explains the open‑source Thanos.sh utility that randomly selects and displays half of the files in a directory on macOS, provides installation steps for required tools, and shows how to modify it for destructive deletion.
This article explains three crucial shell constructs—pipes, redirection operators, and backslash usage—showing how to combine commands, direct output to files, and pass command results as arguments, with practical examples and a script for archiving recently modified files.
This guide outlines a comprehensive Linux incident‑response workflow—identifying suspicious behavior, locating and terminating malicious processes, eliminating virus files, closing persistence mechanisms, and hardening the system—while providing concrete shell commands, monitoring techniques, and remediation tips to effectively combat Linux malware.
This guide explains how to perform time addition and calculate time differences in Bash by converting dates to Unix timestamps, adjusting with arithmetic, and converting results back to readable format, including examples and shell arithmetic operator notes.
