This guide explains how to read, set, and permanently configure Linux environment variables—especially the PATH variable—using commands like export and editing files such as ~/.bashrc, ~/.profile, /etc/profile, /etc/bashrc, and /etc/environment, and details the loading order and practical tips for effective management.
This article compiles a comprehensive set of Linux command‑line shortcuts covering system shutdown, hardware inspection, user management, networking, file handling, compression, performance monitoring, and many other routine administration tasks, providing a handy reference for developers and sysadmins alike.
This article consolidates practical shell scripting standards—covering shebang usage, commenting, parameter validation, naming conventions, encoding, indentation, function structuring, variable scope, efficient command patterns, parallel execution, and static analysis with ShellCheck—to help developers write readable, maintainable, and performant Bash scripts.
Learn five practical Linux techniques—using shell redirection, built‑in commands, /dev/null with cat/cp/dd, echo, and truncate—to clear a file's contents without deleting the file, each with clear examples and explanations.
Learn how to install, configure, and use The Fuck tool on macOS, Linux, and FreeBSD to automatically correct common command‑line typos and errors, with practical examples for sudo, git, and Python commands.
Learn how to effectively locate files on POSIX systems using the versatile ‘find’ command, covering installation, name-based searches, wildcards, regular expressions, modification time filters, type restrictions, depth control, and practical examples for Linux, BSD, and macOS environments.
This guide explains the Linux time command—from basic usage and the meaning of real, user, and sys outputs to advanced GNU time options, custom formatting, and how these metrics help analyze program performance, CPU usage, I/O waits, and context switches.
This article introduces flame graphs, explains their visual characteristics and how they help identify performance bottlenecks in Java applications, and provides practical guidance on generating them using Perl scripts and shell commands to process jstack and perf outputs.
This guide explains how the nohup command lets you run programs that ignore hang‑up signals, redirects their output to nohup.out or a specified file, and keeps them running after you close the terminal, with practical syntax and examples.
This article explains Python's built‑in methods for invoking shell commands—including os.system, os.popen, the commands module, and the subprocess module—detailing their return values, usage examples, and when to choose each approach for capturing command output.
This guide explains the role of the superuser in Linux system management, details how ordinary users can obtain root privileges using the su command, outlines its options and usage examples, and discusses the security trade‑offs of granting root access.
This guide explains how to install, configure, and use the Linux at command for one‑off task scheduling, covering interactive and non‑interactive usage, time expressions, job management with atq/atrm, and differences from cron, all with practical code examples.
This article provides a comprehensive collection of essential Linux command-line instructions covering system shutdown and reboot, hardware and process inspection, file manipulation, networking utilities, performance monitoring, and common administrative tasks, all organized for quick reference by developers and system administrators.
This guide introduces a curated list of powerful cross‑platform terminal utilities—including Windows Terminal, iTerm2, oh‑my‑zsh with plugins, file managers, command‑line enhancers, and miscellaneous tools—designed to help developers feel like a 10× programmer by improving workflow efficiency.
This article clarifies the distinct purposes and usage patterns of the Linux commands su and sudo, explains their parameters such as '-' and '-c', demonstrates user creation, password setting, environment differences between login and non‑login shells, and shows how to configure sudo privileges safely.
Learn how the Linux ‘type’ command reveals whether a given name is an alias, keyword, function, builtin, or external file, and discover its useful options—such as -a, -f, -p, -t, and -P—to control search behavior and output paths.
The article explains the purpose, syntax, options, and practical examples of the Linux unset command, showing how to remove shell variables, environment variables, and functions, while noting its limitations with read‑only variables and providing step‑by‑step demonstrations.
This comprehensive guide covers essential Linux command‑line tools for navigating directories, viewing and manipulating files, searching content, handling permissions, processing text, archiving, system shutdown, and process management, providing practical examples and syntax for each command.
This guide explains the Linux export command, detailing its purpose for converting shell variables and functions into environment variables, the syntax, available options such as -f, -n, -p, and provides practical examples for listing, setting, and removing environment variables.
The article explains the 13‑character fork bomb created by Jaromil in 2002, shows how it exhausts system resources by recursively forking processes, demonstrates its impact on a cloud VM, and provides practical prevention methods using ulimit and limits.conf.
This article shares a collection of powerful kubectl commands and tips—including API debugging, status‑based pod filtering and deletion, node‑specific pod listing, distribution counting with awk, and proxy usage—to help experienced Kubernetes users work more efficiently and avoid manual API client coding.
This guide explains how to use the Linux history command to display past commands, manipulate the history list with options like clearing, appending, reading, writing, deleting entries, and provides practical examples and key notes for effective shell command management.
This article explains the behavior of key Bash special parameters—$*, $@, $#, $$, and $!—through three practical scripts that demonstrate argument expansion, counting, arithmetic operations, and process ID retrieval, highlighting the differences and typical use cases.
This article explains three methods for locating duplicate files on Linux—using a complex find‑pipeline, installing the cross‑platform dupeGuru tool, and a step‑by‑step breakdown of each command in the pipeline—complete with code snippets and usage tips.
This guide shows three practical ways to identify duplicate files on Linux—using an advanced find‑pipeline, installing the cross‑platform dupeGuru utility, and a step‑by‑step breakdown of each command in the pipeline, complete with code examples and explanations.
This guide explains how to use the Linux help command to display built‑in shell command information, outlines its syntax and available options, and provides concrete examples showing short descriptions, manual‑style output, and syntax summaries for commands like pwd.
This article details how to create a VSCode plugin that automates the entire workflow of building, versioning, and publishing a WeChat mini‑program using uni‑app, shell commands, Git operations, Dubbo service calls, and the WeChat DevTools CLI, providing code examples and step‑by‑step analysis.
This guide explains how to use the Linux split command to divide large files into smaller parts and the cat command to concatenate those parts back together, including syntax, practical examples, and help options for efficient file transfer and management.
This guide explains how the Linux history mechanism works, shows essential commands for viewing, filtering, and replaying past commands, demonstrates timestamping, adjusting record limits, changing the history file, disabling logging, and shares a hidden trick for keeping sensitive commands out of the log.
A concise collection of common Linux commands covering file management, user administration, permissions, networking, and editor shortcuts, presented with clear examples and explanations for quick learning and reference.
This article explains how a command’s exit status indicates success or failure in Unix shells, describes the meaning of common return codes, introduces the special $? variable, and provides a comprehensive Bash script example demonstrating various exit scenarios and custom status handling.
This guide explains how Linux aliases work, shows how to create temporary and permanent shortcuts for long commands like rsync, demonstrates listing and removing aliases, and provides step‑by‑step instructions for storing aliases in ~/.bashrc or a separate file.
This article introduces a curated collection of open‑source terminal utilities—including Windows Terminal, iTerm2, oh‑my‑zsh, powerline, file managers, command‑enhancement tools, and other handy programs—explaining their key features and providing links so developers can boost productivity across macOS, Linux, and Windows environments.
Discover ten indispensable Linux commands—from process inspection with pgrep to file splitting with split—complete with explanations, practical examples, and code snippets, empowering developers and system administrators to harness Linux’s powerful capabilities for efficient workflow and system management.
This guide presents a curated list of powerful open‑source terminal utilities—including Windows Terminal, iTerm2, oh‑my‑zsh, file managers, command enhancers, and other handy tools—designed to boost developer productivity and give a feeling of being a 10× programmer.
This guide walks you through installing the Rust‑written Nushell on Linux and macOS, covering prerequisite tools, binary download, extraction, PATH configuration, plugin setup, user creation, default shell change, and a quick test of basic commands.
Learn how to create temporary and permanent Linux aliases to replace lengthy commands, streamline file synchronization with rsync, manage aliases via the alias and unalias commands, and store them in dedicated files for persistent shell customization.
This guide presents 27 practical Linux command‑line techniques—from safe file deletion and alias management to cursor shortcuts, process monitoring, log handling, and advanced scripting—helping power users work faster and avoid common pitfalls.
This article provides a comprehensive reference of Linux commands, explaining their purpose and usage across categories such as file management, system monitoring, networking, user administration, and process control, helping readers efficiently manage and troubleshoot Linux systems.
This tutorial introduces Ansible, outlines its main features, guides you through preparing a lab environment, configuring hosts and the master node, and demonstrates common modules and command options with clear code examples for effective automation.
This article explains the four core parts of a Linux system—kernel, shell, filesystem and applications—covering memory and process management, VFS architecture, file types, directory hierarchy, partitioning, mounting, links and essential command‑line tools.
This article presents seven practical Bash scripts that help Linux administrators quickly gather system status, back up MySQL databases, monitor services, scan network hosts, manage user passwords, and verify MySQL replication, each accompanied by clear code examples and usage instructions.
This guide explains why large files often need to be divided for network transfer on Linux, and provides step‑by‑step commands and options for using the split utility to cut files into smaller pieces and the cat command to recombine them efficiently.
This extensive guide covers Linux fundamentals, including system overview, file system hierarchy, kernel components, user and kernel space, command-line basics, essential commands for file management, networking, security, scripting, and practical examples, providing a thorough introduction for beginners and intermediate users alike.
This article presents a curated list of high‑frequency and low‑frequency command‑line utilities—including fish shell, Starship, z, fzf, fd, ripgrep, htop, glances, Homebrew, asciinema, diff‑tools, tree, bat, httpie, tldr, exa, litecli, mas, and ncdu—explaining their features, installation, and practical usage to boost developer efficiency across Linux and macOS environments.
This comprehensive guide lists the 21 most frequently used Linux commands—from navigating directories and managing files to searching, text processing, compression, system shutdown, and process control—providing a handy cheat‑sheet for developers and system administrators alike.
This article explains the purpose and behavior of key shell special parameters—$*, $@, $#, $$, and $!—through three practical scripts that demonstrate expanding positional arguments, counting arguments, and accessing process IDs, complete with code snippets and expected output.
This guide explains why the ls command shows a fixed 4 KB size for directories, introduces the du (disk usage) utility, and provides step‑by‑step examples for obtaining total, per‑directory, per‑file, and cumulative size information using various du options.
This article shares a curated collection of ready‑to‑run Python and Shell scripts—including Enterprise WeChat alerts, FTP and SSH clients, SaltStack and vCenter utilities, SSL certificate checks, weather notifications, SVN backups, Zabbix password monitoring, local YUM mirroring, and high‑load detection—complete with full source code and usage notes to help engineers automate routine tasks and boost operational efficiency.
This article introduces the Linux `time` command, explains its basic usage and output fields (real, user, sys), distinguishes between shell built‑in and GNU versions, demonstrates advanced options such as custom formatting, file output, and shows how to interpret the metrics for performance analysis.
This article compiles a comprehensive set of Linux shell commands for server health checks—from file cleanup and process inspection to network, disk, and memory monitoring—followed by a handy collection of regular expressions for common validation tasks.
Learn how to effectively use the Linux time command—including its basic output, the meaning of real, user, and sys values, differences between shell built‑ins and GNU time, and advanced options like -p, -v, -o, -f—to accurately measure program performance and diagnose bottlenecks.
This guide demonstrates four practical techniques—input redirection, cat with a pipe, passing the filename as a parameter, and using awk—to read a text file line by line in a Bash script, complete with code snippets and expected output.
This article explains how flame graphs visualize call‑stack frequency and duration, shows how to generate them from Java jstack dumps using Perl tools, and demonstrates how to interpret their widths and flat tops to pinpoint performance hot spots in production systems.
This guide introduces the most important Linux terminal commands—pwd, ls, cd, mkdir, man, touch, nano, and rm—explaining their usage, syntax, and practical tips so developers can navigate, manage files, and work confidently in a shell environment.
This tutorial demonstrates how to use the jq command‑line tool to extract an array of objects from a JSON file, reshape the data into a two‑column format, and output it as properly formatted CSV, including handling of quoting and raw output options.
This article explains how Linux shells store command history in .bash_history, shows basic and advanced usage of the history command—including listing, searching, repeating, timestamping, and configuring history size—and provides practical tricks for auditing, backup, and even disabling history for security purposes.
This article presents a collection of fifteen practical Linux command‑line techniques—including fast file clearing, large file generation, secure disk wiping, process timing, log monitoring, timestamp conversion, and history shortcuts—to help users automate tasks and work more efficiently.
This guide walks through the versatile Linux find command, showing how to locate files and directories by name, type, size, timestamps, permissions, and more, while demonstrating practical examples such as pattern matching, case‑insensitive searches, depth limiting, and executing actions on results.
This article presents fifteen practical Linux command-line techniques—from quickly emptying files and generating large test files to securely erasing disks, monitoring logs, converting timestamps, measuring execution time, handling garbled filenames, retrieving public IPs, batch downloading, and mastering history shortcuts—designed to dramatically improve everyday productivity.
This guide provides a comprehensive overview of Bash’s various bracket types—including parentheses, double parentheses, square brackets, double square brackets, and curly braces—detailing their syntax, typical use‑cases, parameter‑expansion forms, pattern‑matching capabilities, and practical code examples for effective shell scripting.
This article introduces the Linux filesystem hierarchy, explains typical directories, provides solutions for MobaTextEditor garbled text, and offers a concise guide to Vim modes, settings, search/replace commands, and useful shell scripts for system administrators.
This article presents seven hands‑on Bash script examples that cover concurrent hostname collection, process state counting, bulk file renaming, automated jstack logging, GC log analysis, high‑traffic IP detection with conditional reporting, and moving large files while sorting them by size, each with complete code snippets.
This tutorial demonstrates how to use MySQL Shell's three components—MySQL, MySQL X, and SHELL—to connect to a sample WORLD database, perform CRUD operations, execute transactions, and run advanced queries with code examples for each component.
This guide explains how to configure Linux environment variables using various methods such as export, editing ~/.bashrc, ~/.bash_profile, /etc/bashrc, /etc/profile, and /etc/environment, and details the loading sequence and practical tips for effective management.
This article provides a comprehensive cheat‑sheet of the 21 most frequently asked Linux commands, covering file navigation, content viewing, searching, permissions, text processing, archiving, system control, and process management for interview preparation and daily use.
This article provides a comprehensive overview of essential Linux commands for navigating directories, viewing and manipulating files, managing permissions, compressing archives, and controlling system processes, offering practical examples and syntax for each operation.
This article provides a comprehensive introduction to the Bash shell, covering its purpose, user prompts, shebang syntax, execution methods, basic commands like echo and printf, variable handling, environment variables, arithmetic operations, and conditional statements for writing effective shell scripts.
This guide shows how to use the jq command‑line tool to elegantly format, query, and extract data from JSON responses across Linux, Windows, and macOS, providing practical examples, syntax basics, and integration with curl for API testing.
This article presents ten common Linux shell interview questions covering script termination, file header removal, line length checking, viewing non‑printing characters, directory permissions, process lifecycle, cut usage, cmp vs diff differences, echo vs ls substitution, and a brief explanation of inodes, each with clear command‑line solutions.
This guide shows how to enrich Linux Bash history with execution timestamps, associate each command with the user and IP address, and forward the logs to syslog—providing reliable audit trails and protecting against attackers tampering with history records.
This guide compiles twenty practical Linux command-line techniques for analyzing web server logs, revealing visitor IP counts, page popularity, request timing, bandwidth usage, error rates, and connection states, enabling administrators to monitor traffic, detect anomalies, and optimize performance.
This article explains how to use the Linux history command to view past commands, search with Ctrl +r, repeat previous entries, adjust the number of stored records, and clear the history, providing practical examples and configuration tips for effective shell management.
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 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.
