This guide provides a systematic approach to diagnosing Linux server slowdowns by distinguishing CPU, memory, disk, and network bottlenecks through evidence-based metric analysis, command-line tools, and practical examples covering load interpretation, PSI, I/O latency, and safe remediation practices.
This guide details four Linux disk cloning tools—dd, Partimage, Partclone, and Clonezilla—providing installation commands, step-by-step usage instructions, and key considerations like block size trade-offs and filesystem support to help you create reliable backups or migrate drives.
A veteran engineer recounts how deep Linux kernel knowledge resolved a catastrophic zombie-process outage across thousands of CentOS 6 servers, then explores the Unix philosophy of user autonomy, tool composability, and transparent system design that makes Linux essential for serious engineers.
This article provides a comprehensive guide to Linux performance analysis tools, covering vmstat, iostat, dstat, iotop, pidstat, top, htop, mpstat, netstat, ps, strace, uptime, lsof, perf, and advanced tools like eBPF, bcc, and Flame Graphs, with usage examples and output interpretation.
This comprehensive illustrated reference covers Vim's core keybindings across progressive learning levels — from basic navigation and editing to advanced visual mode operations — with practical examples for character, word, line, and screen movement, text insertion, editing, search, and file management.
This comprehensive guide demonstrates how to implement least-privilege access in Linux using sudo, user groups, and ACLs, with practical examples covering identity verification, permission layers, service sandboxing, testing strategies, and account offboarding.
This article traces how C's design — pointers, portability, and a minimal abstraction layer — made it the ideal language for OS kernels, from Unix's 1973 rewrite through Linux's adoption, cementing its dominance despite newer systems languages.
This article outlines eight common mistakes Linux beginners should avoid after installation, including blindly running internet commands, overusing root privileges, deleting system files, adding untrusted repositories, distro-hopping, fearing the terminal, pushing Linux on others, and neglecting backups.
This article explains Linux system architecture covering kernel components (memory, process, device, network management), virtual file system (VFS), disk partitioning, mounting, inode/data block storage, hard vs soft links, and kernel parameter tuning via /proc.
This article introduces five mobile apps — c4droid for C/C++, AIDE for Java, QPython3 for Python, w3cschool for web development, and Termux for Linux — with installation steps and basic usage guides for learning programming on smartphones.
A comprehensive guide to Linux kernel parameter tuning via sysctl, covering network, memory, and filesystem subsystems with a systematic workflow: baseline capture, bottleneck identification, single-parameter changes, validation, persistence, and rollback — illustrated with real production post-mortems.
The article argues that creators of foundational software like Linux, Python, Redis, Nginx, and SQLite are true geniuses due to their exceptional abstraction skills and system-level boundary control, illustrated by real-world cases where their minimal, convergent designs outperform modern complex solutions, and warns that over-reliance on AI tools erodes deep system understanding essential for solving hard production issues.
This article compares traditional file-to-network data transfer (4 copies, 2 CPU copies) with Linux sendfile zero-copy (2 DMA copies, 0 CPU copies), explaining how sendfile eliminates two CPU-mediated copies by moving data directly from kernel page cache to socket buffer, while noting limitations like file-to-socket only, no compression, and UDP incompatibility.
This guide details MySQL scheduled backup using mysqldump commands for full, structural, and data-only exports, a Bash script that retains 31 days of rotating backups with logging, and crontab configuration for automated execution, including restore procedures and practical scheduling examples.
This article introduces 20 Linux command-line tools for network monitoring — such as nethogs, nload, iftop, tcpdump, and ntopng — with installation commands, usage examples, and key features for system administrators across distributions.
A step-by-step tutorial for Ubuntu beginners covering LTS version selection, post-install essentials (apt mirror switch, system update, GPU drivers, Chinese input method, fonts), development environment setup (Git, Python with venv, Node.js via nvm, Docker, VSCode), common pitfalls like DNS errors and driver black screens, and survival habits including Timeshift snapshots and config backups.
The split between /bin and /usr/bin originated in 1971 when Ken Thompson and Dennis Ritchie ran out of space on a 1.5MB PDP-11 disk, prompting them to spill overflow commands onto a second disk mounted at /usr—a pragmatic hack later mythologized as intentional design, causing decades of confusion until modern distributions merged them via usrmerge.
This comprehensive guide compares find and locate for large-scale Linux file retrieval, covering performance bottlenecks, safe deletion practices, inode exhaustion troubleshooting, and production-ready scripts with dry-run, trash-based cleanup, and monitoring integration for million-file environments.
The article recounts SCO Group's 2003 $5 billion lawsuit against IBM over alleged Unix code in Linux, detailing how Linus Torvalds' 1992 switch to GPLv2 made Linux impossible to monopolize, how Torvalds publicly debunked SCO's code claims line-by-line, how a 1995 contract revealed SCO never owned the Unix copyrights, and how the case led to the kernel's Developer Certificate of Origin (Signed-off-by) still used today.
This guide explains how to identify which process is occupying a network port on Linux using netstat, ss, and lsof commands, with detailed flag explanations and real output examples for troubleshooting 'Address already in use' errors.
This tutorial explores 20 practical ls command options for Linux, covering long listing, human-readable sizes, sorting by size or time, showing hidden files, inode numbers, recursive listing, and version information, with clear examples for each flag.
This guide details five essential Linux commands—top, free, df, netstat, and tcpdump—for diagnosing server-level CPU, memory, disk, and network bottlenecks that cause Java application failures, providing field interpretations, anomaly thresholds, and a step-by-step troubleshooting workflow.
A comprehensive, scenario-driven reference covering 30+ categories of Linux operations commands — system info, processes, CPU, memory, network, disk, files, logs, users, services, packages, scheduling, performance analysis, text processing, SSH, troubleshooting workflows, dangerous commands, auditing, and efficiency tips — each with purpose, key parameters, real-world examples, and risk warnings.
A comprehensive guide to recovering from accidental rm -rf deletions on Linux, covering immediate response, file system internals (ext4/xfs/btrfs/zfs), multiple recovery tools (extundelete, debugfs, lsof, snapshots), a real incident timeline, risk assessment, and prevention strategies including code review, monitoring, and backup practices.
This article presents 17 practical Linux command-line techniques for system administrators, covering file search and manipulation with find and sed, log analysis using awk and sort, disk space monitoring with automated alerts, network packet capture via tcpdump, firewall configuration with iptables, and shell scripting for routine maintenance tasks.
This comprehensive guide dissects the Linux logging stack — kernel ring buffer, journald, rsyslog, logrotate, and service logs — with configuration details, command references, and five step-by-step troubleshooting cases covering SSH brute force, disk exhaustion, OOM kills, network packet loss, and systemd service failures.
This article teaches practical Linux log analysis commands (tail, less, grep, sed, awk) with real-world scenarios like monitoring service startup, tracing orders, extracting error context, searching across rolled logs, counting exceptions, filtering noise, slicing time windows, and analyzing Nginx logs for top IPs and slow endpoints.
The tinywan/webman-typephp plugin automates TypePHP AOT compilation for Webman 2.x projects, generating a portable Linux binary directory with a Docker-based builder that eliminates manual C++ toolchain setup.
Linus Torvalds notes Linux 7.3-rc2 is unusually large with fixes across filesystems, DRM, networking, BPF, and drivers, humorously suggesting AI as a scapegoat, while also admitting his own mid-merge-window system upgrade complicated the previous rc1 release.
This comprehensive guide covers 20 essential Linux commands for system administrators, including file management, process monitoring, network diagnostics, and text processing, with practical examples, common parameters, and safety tips for production environments.
The 1992 Usenet debate where Andrew Tanenbaum called Linux's monolithic kernel obsolete is revisited, revealing how Linux came to dominate servers, phones, and supercomputers, while Minix quietly became the hidden OS inside Intel's Management Engine on hundreds of millions of x86 chips, making both architects unexpected winners.
An experienced operations engineer shares the key skills that differentiate senior professionals, including troubleshooting methodology, automation, cloud-native technologies, monitoring systems, security practices, business alignment, SRE principles, AI-assisted operations, and continuous learning, emphasizing that Linux is merely the foundation.
This guide walks operations engineers through IP addressing, binary‑decimal conversion, classful and private address ranges, subnet masks and CIDR notation, gateway functions, VLAN concepts, routing tables, DNS basics, Docker/Kubernetes networking, firewall rules, and practical troubleshooting steps, all illustrated with concrete commands and examples.
The article explains the three fundamental process states—Running, Ready, Blocked—their characteristics, how they convert between each other, the role of the Process Control Block, Linux‑specific state extensions, and provides illustrative code and diagrams to clarify OS scheduling concepts.
The Debian community recently voted, using a Condorcet method, to permit developers to use generative AI for code and documentation as long as they retain final responsibility for quality and legal compliance, while encouraging but not mandating disclosure of AI assistance.
The article maps modern AI Agent terminology — identity isolation, least privilege, sandbox, runtime, scheduler, observability, human-in-the-loop, secure execution, self-healing — to decades-old Linux concepts like user permissions, chmod, directories, sudo, systemd, cron, journalctl, SSH, Docker, and process supervision, arguing that Linux veterans already manage AI agents as just another untrusted user.
This comprehensive guide explains Linux's permission model, demonstrates numeric and symbolic chmod usage, details chown operations, introduces ACL for fine‑grained control, and provides troubleshooting steps and security best practices for production environments.
The article reveals that the hype around AI Agents masks a set of mature Linux system management features—user isolation, least‑privilege permissions, sandboxed workspaces, sudo restrictions, systemd daemons, cron scheduling, journald logging, SSH access, Docker containers, auto‑restart, multi‑process coordination, and Redis caching—showing that understanding Linux gives developers a clear advantage.
Celebrating Linux’s 35th birthday, the article traces how Linus Torvalds’s modest 1991 Usenet post evolved into a 40‑million‑line kernel that now powers every top‑500 supercomputer, the majority of web servers, Android smartphones, cloud platforms and even space rockets.
This guide explains the principles, syntax, common parameters, practical examples, error handling, and performance differences of scp and rsync, helping system administrators decide which tool to use for small one‑off copies, large incremental syncs, bandwidth‑limited transfers, and production deployment scenarios.
The article explains why using Wine—a free, open‑source API‑compatibility layer that re‑implements Windows interfaces—to run licensed Windows programs on Linux does not constitute copyright infringement, illustrating the reasoning with real‑world examples and legal considerations.
The article explains segment‑paging memory management by comparing pure paging, pure segmentation, and their combination, detailing address translation, two‑level page tables, Linux implementation, and practical scenarios such as process layout inspection, fragmentation handling, and protection mechanisms.
This guide explains why mastering the Linux directory hierarchy is essential for sysadmins, outlines the FHS standard, details each top‑level directory such as /etc, /usr, /var, and provides practical commands, examples, and safety tips for navigating, troubleshooting, and managing files across common distributions.
Linux users can run WeChat through several community‑driven approaches—including deepin‑wine, virtual machines or Docker containers, third‑party Electron wrappers, and simply using the mobile app—each with its own trade‑offs in stability, isolation, and convenience.
This comprehensive guide introduces tcpdump, the Linux equivalent of Wireshark, and walks through 20 frequently used command combinations covering basic packet capture, filtering by host, port, protocol, output formatting, performance tuning, advanced BPF filters, real‑world troubleshooting scenarios, and best‑practice recommendations for production environments.
This guide explains why network traffic can be blocked despite seemingly correct firewall rules, detailing a systematic troubleshooting process that examines each layer from the client to the application, includes concrete command examples, Docker-specific considerations, and verification steps to pinpoint and resolve the issue.
This article categorizes essential Linux commands for Java developers, explains why interviewers focus on real‑world usage, provides scene‑based command tables, demonstrates log‑analysis and performance‑monitoring workflows, and offers concise answers to common interview follow‑up questions.
This extensive article explains Linux memory management fundamentals, covering physical and virtual memory, allocation and release mechanisms, key kernel functions, performance tuning, leak detection, fragmentation handling, and real‑world code samples for developers and system engineers.
The article explains why Linux servers often experience slow boot times, outlines a systematic method to analyze each stage of the boot chain—from firmware to user services—identifies common bottlenecks, and provides concrete systemd, BIOS, GRUB, initramfs, and service‑level optimizations with commands and verification steps.
WITR is an open-source troubleshooting tool that unifies Linux process, port, file, and service queries into a single ancestry chain, showing not just what is running but why—via process parentage, systemd, containers, and Git context—with JSON output for automation.
This article curates ten noteworthy open‑source projects—from a ready‑to‑use Linux distribution and AI knowledge‑graph infrastructure to peripheral managers, AI agent frameworks, model‑training tools, and ultra‑light tool‑calling models—detailing their core features, use cases, and GitHub links for developers to explore.
The article explains how the Linux Deadline real‑time scheduler works, detailing its three core parameters (runtime, period, deadline), the EDF algorithm, kernel data structures, CBS bandwidth control, task state transitions, common configuration pitfalls, and practical tuning and monitoring commands.
This article walks through TCP fundamentals, explains each step of the three‑way handshake and four‑way termination, examines kernel parameters, common connection‑state problems such as TIME_WAIT and CLOSE_WAIT, and provides practical commands and scripts for diagnosing and tuning TCP on Linux.
This guide walks you through a systematic, layer‑by‑layer approach to pinpointing occasional network packet loss by examining application logs, checking TCP connection stats with ss, reviewing kernel counters, tracing routes with mtr, and analyzing traffic with tcpdump, then applying targeted fixes.
Omarchy, DHH's AI‑native Linux distro, combines Arch, Hyprland, and built‑in AI agents to deliver a fast, developer‑friendly experience, and this article shows Ubuntu users five concrete ways to recreate its key advantages without reinstalling the whole system.
This guide presents 30 of the most frequently used Linux commands for operations engineers, organized into seven categories and illustrated with real‑world scenarios, parameter examples, safety warnings, and step‑by‑step usage tips to help you manage files, monitor systems, handle processes, diagnose networks, control users, compress data, and manage services.
This article curates ten noteworthy open‑source projects—from a ready‑to‑use Linux distro and AI‑traceable knowledge‑graph tools to peripheral managers, plugin frameworks, local model selectors, and lightweight training utilities—providing concise descriptions, key features, and direct GitHub links for each.
This article presents a practical checklist of 20 Linux kernel parameters—grouped by network, memory, process, and filesystem settings—explaining their default values, typical failure symptoms, step‑by‑step tuning commands, verification methods, and rollback procedures to ensure production systems such as web servers, databases, caches, and containers run without kernel‑level bottlenecks.
This article explains the four main components of a Linux system—kernel, shell, file system, and applications—detailing kernel subsystems, memory and process management, the virtual file system, device drivers, network stack, mounting mechanisms, partition types, link types, and common administration commands.
This guide explains how to use the Linux tools top, vmstat, and iostat to systematically identify CPU, memory, or disk I/O bottlenecks on a server that becomes progressively slower, offering step‑by‑step analysis, example scenarios, and practical optimization advice.
The article showcases a collection of Linux commands that can cause severe system damage or data loss, illustrated with screenshots, warning users that executing these commands without full understanding can be extremely risky.
This article walks through a complete Linux network‑packet‑loss investigation, from identifying loss points across the protocol stack, using ethtool, netstat, tc, iptables and tcpdump, to removing a faulty netem rule and correcting an MTU setting, ultimately restoring Nginx HTTP responses.
A viral statement by Canonical’s VP that Ubuntu’s WSL user base will soon outpace native Ubuntu was widely misinterpreted as a total‑user‑count surge, when it actually refers to a faster growth rate, a nuance that reveals shifting enterprise developer trends and strategic implications for Linux adoption.
A production server hit 100% disk usage, prompting the author to use df, du and find to locate oversized log files, uncover missing rotation, excessive debug logging and a looping exception, then perform urgent cleanup and implement logrotate, log level adjustments, and Prometheus alerts to prevent recurrence.
This guide walks ops engineers through installing nmap, understanding its scan techniques, executing single‑port, common‑port, full‑range, and script‑based scans, analyzing results, and applying remediation steps such as firewall rules, service hardening, and regular scanning schedules to keep server exposure minimal.
This tutorial walks through compiling PHP into a native executable with TypePHP, covering Windows quick‑start using the official toolchain, a seven‑step Linux setup, project.yml configuration, three build modes, and a complete Windows Tetris example.
This comprehensive guide examines Linux compression and decompression, comparing tar, gzip, and zip in depth, covering algorithm fundamentals, performance benchmarks, practical command examples, automation scripts, security considerations, and best‑practice recommendations to help engineers choose the optimal tool for backup, deployment, and data transfer tasks.
The article compiles several Zhihu answers explaining why Linux dominates server deployments, covering early Windows‑IIS dominance, open‑source ecosystem effects, performance and cost advantages, licensing fees, container support, and the long‑term Matthew‑effect that cemented Linux’s position.
The article compiles several Zhihu contributors' explanations for why Linux dominates server deployments, covering historical Windows server limitations, licensing costs, ecosystem momentum, performance advantages of Apache/Nginx, container suitability, and Microsoft's evolving stance on open source.
Linux kernel 7.2 arrives with cache‑aware scheduling for AMD EPYC and Intel Xeon CPUs, late DRM rollbacks, a quirky Zenaim Leverless game controller, deprecation of PCMCIA and AppleTalk, and work to run efficiently on Apple M3 Macs, all announced by Linus Torvalds as a "new normal" driven by AI‑assisted development.
A seasoned operations veteran shares a step‑by‑step incident‑response workflow, the SEAL troubleshooting methodology, essential monitoring and debugging tools, real‑world case studies, automated scripts, and best‑practice guidelines to help engineers quickly diagnose and resolve production outages.
The article explains that replacing Linux’s default 4 KB pages with 2 MB huge pages may reduce TLB misses but often degrades performance for typical micro‑service workloads, causing memory bloat, cache conflicts, and latency spikes, and demonstrates the issue with benchmark code and a step‑by‑step rollback guide.
This article explains the differences among Connection reset, Read timed out, and Connect timed out, outlines typical causes for each, provides step‑by‑step Linux command checks, Java Spring Boot configuration examples, a real‑world case study, and a quick‑reference cheat sheet for troubleshooting network timeouts.
This comprehensive guide walks junior to mid‑level system administrators through Linux log fundamentals, essential command‑line tools like grep, awk, sed and journalctl, and step‑by‑step troubleshooting scenarios for SSH, service failures, disk space, memory leaks, security incidents, and application logs, providing practical scripts and advanced techniques for effective log‑driven problem resolution.
After testing almost every mainstream Linux file manager for half a year, the author concludes that Dolphin offers the best balance of usability, rich features, split‑view browsing, seamless network access, and an embedded terminal, making daily work significantly more efficient.
This article examines Ladybird, an open‑source browser that breaks the Chromium/Gecko monopoly with a fully self‑written engine, a five‑process sandbox architecture, cross‑platform support for Linux, macOS and WSL2, and provides detailed compilation steps, security analysis, and suitability guidance for developers.
This guide explains how attackers can conceal file‑modification timestamps on a Linux server by using the touch and stat commands, organizing a Bash script to save and restore timestamps, and automating the process to erase forensic evidence of malicious activity.
This article explains Linux process virtual address spaces, details the multi‑step internals of the C++ new operator, and analyzes its memory‑fragmentation, time, and space overheads through code examples and benchmarks, then offers practical mitigation techniques such as memory pools and smart pointers.
UART remains the go‑to debugging interface in embedded projects because it needs only three wires, works asynchronously, enjoys universal driver support, and benefits from decades of Unix‑style console tradition, whereas SPI and I2C were never designed for simple human‑machine interaction.
The article explains that reducing page load from five seconds to 500 ms requires more than just tweaking a few Nginx directives, outlines a systematic workflow—baseline measurement, hypothesis, single‑parameter gray rollout, verification and rollback—and details twelve specific Nginx settings that can eliminate proven Web‑layer bottlenecks such as file‑descriptor limits, connection models, static‑file paths, compression and request buffering.
This article introduces five core Linux file comparison utilities—diff, colordiff, wdiff, vimdiff, and sdiff—explaining their syntax, key options, installation steps, and practical examples so readers can choose the right tool for their workflow.
This article presents a practical guide for system administrators and DevOps engineers, introducing ten high‑frequency Linux tools—htop, iotop, nethogs, ncdu, strace, lsof, tcpdump, netstat/ss, curl, and systemctl/journalctl—detailing their installation, core and advanced usage, real‑world case studies, and how to combine them to dramatically improve troubleshooting speed and overall operational efficiency.
This article introduces RedisInsight, the official visual management tool for Redis, outlines its key features, provides step‑by‑step installation on Linux and Kubernetes, and demonstrates basic usage for monitoring, querying, and memory analysis through the GUI.
This article walks through a systematic, three‑stage method—starting with a 60‑second global scan using uptime, top, vmstat and mpstat, then pinpointing the offending process and thread with pidstat, perf and strace, and finally classifying the root cause to apply the appropriate fix—so you can diagnose and resolve Linux CPU spikes without resorting to blind restarts.
The article explains how a file system works—from physical disks to logical structures—using analogies like warehouses, detailing superblocks, inodes, data blocks, tree hierarchies, common file systems, Windows C‑drive growth, Linux ext4 features, permission models, and the role of the virtual file system.
The author reflects on how Windows once felt exciting but has become generic, while Linux offers a vibrant ecosystem of diverse distributions and customizable desktop environments that rekindle the pleasure of tinkering and finding a system that truly fits one's personal workflow.
This article explains Linux signal fundamentals—including generation, registration, dispatch, masking, and handling—covers standard and real‑time signals, common pitfalls like non‑reentrancy and EINTR, and provides concrete C/C++ code examples for each scenario.
The article explains how Linux’s single‑root filesystem, governed by the Filesystem Hierarchy Standard (FHS), resolves early Unix directory chaos through hierarchical organization, functional separation, predictability, and economic design, and details the responsibilities of each standard directory.
Linus Torvalds observes that AI tools are now reviewing countless patches, turning the Linux kernel's RC6 release into an unprecedentedly large update, yet he remains confident the 7.2 kernel will ship next weekend despite the size concerns.
This article compiles a comprehensive guide to Linux performance analysis utilities, covering basic commands like vmstat, iostat, dstat, top, htop, and advanced tools such as perf, eBPF, Flame Graphs, and sar, with usage examples, output explanations, and practical tips for system monitoring and tuning.
The article explores the Linux kernel’s most impressive designs—including the CFS scheduler, VFS abstraction, memory management tricks, extensible networking stack, driver framework, signal handling, and container foundations—illustrating how they solve real‑world constraints across diverse platforms.
When a Linux server reports a full disk, the article explains three possible causes—actual space exhaustion, inode depletion, or deleted files still held by processes—and walks through eight essential commands, from df and du to lsof, ncdu, iostat, and journalctl, to diagnose and safely resolve the issue.
Linux favors tar.gz because it follows the Unix philosophy of single‑purpose tools, preserves file permissions and metadata, is universally available without extra installation, offers flexible compression options, and benefits from a mature ecosystem, whereas ZIP loses metadata and 7Z requires extra tools and is slower.
This article narrates a step‑by‑step investigation of a sudden CPU load spike on a 24‑core e‑commerce web server, revealing an I/O bottleneck caused by misconfigured log rotation and excessive debug logging, and outlines the diagnostic commands, root‑cause analysis, immediate remediation, and long‑term fixes.
Anthropic's Claude Code now lets AI agents exchange messages between separate sessions on macOS or Linux, eliminating manual copy‑paste, synchronizing context for parallel tasks, and enabling proactive notifications and coordinated workflows without any configuration.
This guide explains how to break down the vague symptom “network unreachable” into layered checks—interface status, routing, ARP, DNS, TCP, TLS, and HTTP—using the four classic tools ping, telnet, curl, and traceroute, and provides concrete commands, analysis steps, and evidence‑gathering scripts for Linux servers and Kubernetes pods.
This article compiles over 100 common DevOps and operations interview questions sourced from leading Chinese tech firms such as ByteDance, Meituan, Alibaba, Tencent and JD, providing a comprehensive study guide for candidates aiming to secure high‑salary offers.
Claude Code now lets AI sessions on different terminals exchange concise, Claude‑generated summaries, supporting handoff detection, parallel worktree coordination, long‑running task status, and cross‑machine replies while preserving privacy and respecting permission controls.
The article explains that an operating system acts as a computer's "big steward," handling memory allocation, process scheduling, hardware abstraction, and security, and then compares Windows, macOS, and Linux in market share, strengths, and typical use cases.
F* is a proof‑oriented programming language developed by Microsoft Research, INRIA and the open‑source community that generates mathematically verified C code used in critical components such as Firefox’s TLS handshake, Linux’s WireGuard crypto, Azure packet parsing, and even blockchain smart contracts, offering zero‑day‑free security at the cost of higher proof‑writing effort.
