This article explains the fundamentals of Linux network latency, demonstrates how to measure round‑trip time using ping, traceroute, hping3 and wrk, walks through a Docker‑based test setup, and shows how to analyze packet captures with tcpdump and Wireshark to uncover causes such as TCP delayed ACK.
The article analyzes the growing demands on network I/O, explains Linux’s kernel bottlenecks, and shows how user‑space frameworks like DPDK and UIO can achieve multi‑hundred‑million packets per second through techniques such as huge pages, SIMD, zero‑copy, and careful CPU cache management.
This article provides a step‑by‑step tutorial on installing Nginx, setting up reverse proxy and various load‑balancing methods, configuring upstream directives, deploying Keepalived for high‑availability failover, and building an LVS‑DR cluster to achieve robust, production‑grade traffic distribution.
Linux load average, a key performance metric, is computed by periodically aggregating per‑CPU runnable and uninterruptible task counts into a global instantaneous load, then applying an exponential weighted moving average to produce 1‑, 5‑, and 15‑minute averages, which are exposed to user space via the /proc/loadavg pseudo‑file.
This guide walks through installing Supervisor from source, resolving dependencies, creating configuration files, defining custom program entries, starting the service, reloading configurations, and using supervisorctl to monitor and control processes on a Linux server.
A PyTorch‑nightly supply‑chain attack introduced a malicious "torchtriton" package on PyPI that exfiltrated IP addresses, hostnames, usernames and SSH keys from Linux systems, prompting an urgent uninstall notice and a swift response from the PyTorch team.
nettrace is an eBPF‑powered command‑line utility that traces a packet’s full kernel lifecycle, diagnoses network faults with a built‑in knowledge base, monitors anomalies and skb drops, supports NAT, GRE, IPVS and netfilter hooks, and replaces legacy tools like tcpdump and droptrace in cloud‑native Linux environments.
This article explains Linux load average, covering how it is calculated, its relationship with CPU usage, and how the kernel exposes load data to applications.
This article explains how Linux handles I/O operations, covering the virtual file system, inode and dentry structures, superblock layout, ZFS features, disk types, the generic block layer, I/O scheduling strategies, and key performance metrics for storage.
This guide provides a comprehensive overview of Linux operating system fundamentals, covering installation references, filesystem hierarchy, essential command-line operations, user and group management, permission handling, process control, and common software installation methods, complete with practical examples and command syntax.
This article compiles a practical collection of Linux command‑line snippets covering file searching, batch extraction, text manipulation with sed, directory checks, disk usage monitoring, log analysis, firewall rules, and other common sysadmin tasks, each illustrated with exact command examples and brief explanations.
This comprehensive guide explains Ceph's background, architecture, key features, terminology, step‑by‑step cluster deployment on CentOS, dashboard setup, CephFS creation, and a Java client example, providing everything needed to build and operate a reliable distributed storage system.
This comprehensive guide explores Linux memory fundamentals, covering memory organization, address spaces, MMU translation, fragmentation, buddy and slab allocation algorithms, kernel and user memory pools, DMA, shared memory, common pitfalls, and practical tools for monitoring and optimizing memory usage in Linux systems.
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.
The article shares a developer’s journey from Android app development to framework development, detailing motivations, environment setup, daily tasks, challenges, essential skills, and a structured learning roadmap for mastering Android’s system layers.
This comprehensive guide explains Linux's core components—including the kernel, shell, memory and process management, virtual file system, device drivers, networking, and mounting—while detailing filesystem types, directory structures, link types, and practical commands for managing partitions and mounts.
This comprehensive guide covers Linux operating system fundamentals, installation steps, filesystem hierarchy, essential command-line utilities, user and group management, permission handling, process control, and software installation methods, providing practical examples and clear explanations for beginners and developers alike.
This comprehensive guide walks through Linux process creation with fork, explains its return values and copy‑on‑write behavior, covers normal and abnormal termination using return, exit and _exit, details waiting with wait/waitpid, and demonstrates program replacement via exec functions and a simple custom shell.
This guide introduces Multipass, a lightweight cross‑platform VM manager, walks through installation on Windows, demonstrates how to list, launch, and configure Ubuntu instances, shows essential commands for inspecting, pausing, restarting, deleting, and automating setups with cloud‑init, and compares it to paid tools like VMware Workstation.
This guide explains how to create and extract common Linux compression formats—including zip, gzip, bzip2, tar.gz, and tar.bz2—by using the appropriate command‑line options, showing practical examples for files and directories.
This article reviews the five most notable Linux desktop distributions released in 2022—Ubuntu 22.04 LTS, Fedora Workstation 37, Manjaro 22.0 “Sikaris”, Linux Mint 21, and Ubuntu 22.10—highlighting their key features, stability, and why they matter to programmers and system administrators.
Discover seven visually striking Linux distributions—elementary OS, Deepin, Pop!_OS, Manjaro, KDE Neon, Zorin OS, and Nitrux—each offering unique aesthetics, user-friendly interfaces, and strong Ubuntu or Debian foundations, making them standout choices for users seeking both beauty and functionality in a desktop environment.
This article introduces nginxWebUI, a web‑based graphical interface for managing Nginx configurations, explains its technical architecture, provides step‑by‑step installation instructions for jar, Docker and systemd service on Linux, and demonstrates how to use the UI for HTTP, TCP, SSL, load‑balancing, and remote server management.
This article explains the fundamentals of Ceph cache tiering, covering cache and buffer concepts, the two cache‑pool modes (write‑back and read‑forward), step‑by‑step deployment, configuration parameters, and proper procedures for creating, tuning, and safely removing cache pools.
This article explains what Unix signals are, categorizes reliable and unreliable signals, describes how they are generated by hardware and software, and details registration, blocking, pending states, handling functions, and common usage examples with C code.
This article walks through Linux kernel physical memory allocation, explaining the hierarchy of allocation interfaces, the role of gfp_mask and ALLOC flags, the fast and slow allocation paths, memory watermarks, NUMA zone handling, and the complex fallback mechanisms including compaction, direct reclaim, and OOM, all illustrated with code snippets and diagrams.
This guide explains how to prevent idle SSH sessions from being terminated by adding a ServerAliveInterval setting to the user‑level or system‑wide SSH configuration files, ensuring the connection stays alive without compromising security.
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 explains how Linux creates and allocates PID namespaces, how Docker containers obtain their own PID namespaces using CLONE_NEWPID, the internal kernel structures involved, and how processes view their PID inside a container.
This guide walks through setting up a Linux environment with a custom YUM repository, installing Google Chrome, and using headless Chrome commands to search, capture screenshots, and access Douyin pages directly from the command line.
This article explains Linux connection tracking (conntrack), its implementation in Netfilter, and provides detailed instructions for using iptables—including rule queries, additions, deletions, modifications, saving, loading, match extensions, custom chains, and logging—to manage firewall behavior and network security effectively.
This article introduces DataX, an open‑source data integration tool, explains its architecture, and provides step‑by‑step instructions—including environment setup, installation, job JSON creation, and command execution—to achieve fast full‑ and incremental synchronization between MySQL databases.
This article provides a comprehensive overview of iptables, detailing its host‑type filter table, limitations, the four main tables (filter, nat, mangle, raw), their respective chains, common command examples, and explains NAT concepts such as SNAT, DNAT, and MASQUERADE for Linux network security.
This guide explains the netstat command’s purpose, interprets its output sections for active Internet connections and UNIX domain sockets, details common options such as -a, -t, -u, -l, -p, and provides numerous practical examples for listing ports, monitoring traffic, displaying routing tables, and identifying processes.
This guide explains the fundamentals of distributed file systems, compares them with traditional storage, introduces MinIO’s architecture and features, and provides step‑by‑step instructions for deploying a multi‑node MinIO cluster with Nginx load balancing on Linux.
The article explains how TCP connections are identified by a four‑tuple, clarifies the theoretical maximum of 65,535 client ports versus the far larger possible server connections, and discusses practical limits imposed by memory, file descriptors, and system configuration on Linux servers.
This article introduces eBPF, explains its origins and how it extends BPF for kernel‑level observability, compares it with SystemTap and DTrace, outlines common use cases, details its loading‑compile‑execute workflow, and provides step‑by‑step Python/BCC examples with installation instructions and advanced latency measurement code.
This guide explains what crontab does, how to write and manage user and system cron jobs, shows real‑world syntax examples, highlights typical pitfalls such as environment variables, time fields, special characters and output redirection, and provides debugging strategies including the crontab.guru online parser.
This article examines the evolving demands of network I/O, analyzes Linux and x86 bottlenecks, explains DPDK's user‑space bypass architecture, and presents practical optimization techniques—including huge pages, SIMD, cache prefetching, and compile‑time tricks—to achieve multi‑gigabit packet processing rates.
Linus Torvalds sharply criticized Intel’s new Linear Address Masking feature, deeming its kernel implementation fundamentally broken and refusing to merge it into Linux 6.2, while Intel plans to rewrite the code for a future release.
This article explains the fundamentals of Linux memory management for C++ backend services, covering memory size categories, lifetime classifications, allocation mechanisms such as kmalloc, vmalloc, brk, mmap, virtual‑to‑physical mapping, lazy allocation, and the performance considerations that guide efficient memory usage.
This article demonstrates how to package a Spring Boot application using Maven profiles and the Maven Assembly Plugin to create a zip release, and provides a reusable shell script (shenniu_publish.sh) for extracting, starting, stopping, and restarting the service on Linux.
This article explains what eBPF (extended Berkeley Packet Filter) is, compares it with related tracing tools, describes its core mechanisms and common applications such as network monitoring, security filtering and performance analysis, and provides step‑by‑step Python examples with installation instructions and further reading resources.
Using lightweight dynamic‑tracing tools that record allocator calls and page‑fault events, the authors diagnose a production MySQL‑proxy memory leak in TDSQL, generate focused flame‑graphs with custom memstacks and pgfaultstacks, and demonstrate a fast, source‑independent alternative to gdb or Valgrind.
This guide explains essential Linux networking commands—including ip, ifconfig, netstat, ping, traceroute, host, dig, systemd-resolve, and dhclient—showing how to view interfaces, check connectivity, trace routes, query DNS records, and manage DHCP leases for effective troubleshooting.
Elon Musk announced his resignation as Twitter CEO following a poll, while Google’s Sundar Pichai highlighted AI’s broader impact and unveiled Google Lens handwriting recognition, Linux integrated Zstd 1.5.2 into kernel 6.2, GitLab released a Web IDE beta, and PHP 8.2 introduced readonly classes and new types.
This guide explains how to detect traffic attacks on a low‑traffic Linux website, split Nginx logs daily, identify IPs with excessive requests, and automatically block them using iptables rules scheduled via cron, complete with ready‑to‑run Bash scripts and common firewall commands.
This guide explains how to read, set, and persist Linux environment variables using various commands and configuration files, compares multiple configuration approaches, and details the exact sequence in which the system loads these files for both user‑level and system‑wide settings.
This article explains how Linux’s free command reports memory usage, clarifies the roles of buffer and page caches, demonstrates which caches can be reclaimed, and shows why tmpfs, shared memory, and MAP_SHARED mmap allocations remain in cache until explicitly released.
This guide explains how to use Linux's TC tool to shape traffic by creating qdisc, class, and filter rules, allowing you to limit outbound and inbound bandwidth for specific IP addresses or ports, with step‑by‑step commands and practical examples.
This guide explains how to use the Linux df command with real‑world examples, covering human‑readable output, inode statistics, total usage, filesystem types, inclusion/exclusion filters, specific mount points, and virtual filesystems to help you monitor disk space effectively.
This guide walks through creating a backup directory, performing a full XtraBackup of MySQL, adding data, executing an incremental backup, simulating accidental database deletion, and then restoring the instance step‑by‑step using preparation, copy‑back, permission fixing, and binlog recovery.
Learn practical Linux commands—dd, truncate, and fallocate—to generate large files of specific sizes for testing or troubleshooting, with clear examples and tips on choosing the fastest method.
This guide introduces ten lesser‑known Linux commands—including rsync, screen, lsof, vimdiff, netcat, and more—explaining their key options, practical use‑cases, and example invocations so you can work faster, automate tasks, and troubleshoot systems efficiently.
This article investigates Linux's handling of files that are in use—whether opened for reading, running as executables, or loaded as shared libraries—by experimenting with deletion, replacement, and modification, revealing how the kernel preserves file contents via inode references until all processes release them.
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.
Learn how to install and configure the latest Linux Kernel 6.0 on Ubuntu 22.04, covering prerequisites, system updates, downloading source, configuring modules, compiling, installing, updating GRUB, and verifying the new kernel with detailed commands and screenshots.
This article explains what Unix signals are, categorizes reliable and unreliable signals, describes how they are generated by hardware and software, and details registration, blocking, pending states, handling functions, and practical code examples for custom signal processing.
This guide explains how logrotate automates log rotation, configures rotation intervals, size limits, compression, and post‑rotation scripts, helping you manage growing log files, conserve disk space, and maintain system performance on Linux servers.
This article walks through the fundamentals of Linux log management by introducing Rsyslog, showing how to install it on CentOS, configure facilities and severity, and demonstrate practical examples for aggregating web server access logs to a central application server.
This guide explains the four main stages of a typical Linux boot sequence—BIOS POST, GRUB2 loading, kernel initialization, and systemd startup—detailing the hardware checks, bootloader behavior, init process, target units, and useful commands for inspecting and changing runlevels.
This article explains the Linux OOM Killer’s trigger and selection process, walks through the key kernel functions and heuristics that choose a victim process, and clarifies why out‑of‑memory conditions occur under different overcommit settings.
The article explains how glibc’s default ptmalloc allocator structures memory into main and non‑main arenas, uses chunk‑based bins (fast, unsorted, small, large) for allocation and deallocation, details its locking and OS‑interaction mechanisms, and evaluates its design trade‑offs versus modern allocators.
BBRv2 improves upon the original BBR algorithm by more accurately measuring delivery rate, constraining inflight data with loss and ECN signals, and introducing a dynamic state machine that enhances fairness and coexistence with Reno/CUBIC, addressing the multi‑flow fairness and queueing issues that plagued BBRv1.
This guide explains how to use Linux's TC tool with qdisc, class, and filter to shape outbound traffic, limit specific IP/Port bandwidth, and handle inbound traffic via IFB redirection, providing step‑by‑step commands and configuration examples.
This article explains why using the Linux kill -9 command to stop Java services can cause data loss, demonstrates the differences between forceful and graceful termination, and provides multiple Spring Boot shutdown solutions—including kill -15, actuator endpoints, custom Tomcat connectors, and @PreDestroy hooks—complete with code examples.
This article explains the Linux kernel’s packet‑receiving workflow, the role of hardware and soft interrupts, how ksoftirqd processes deferred work, includes key code excerpts, and shows how to monitor softirqs to diagnose performance issues.
This guide explains Linux shell fundamentals, how the shell interacts with the kernel, user and file permission concepts, command examples for switching users, modifying permissions with chmod, ownership with chown, group with chgrp, the role of umask, and the sticky bit for secure directory management.
This article explains how Linux’s free command reports memory usage, clarifies the roles of buffer and page caches, and demonstrates through practical experiments why certain caches—such as those used by tmpfs, shared memory, and MAP_SHARED mmap regions—cannot always be reclaimed as free memory.
This article provides a comprehensive guide to Linux fundamentals, covering OS concepts, installation steps, filesystem hierarchy, essential command-line tools, user and group management, permission handling, process control, and common software installation methods.
This guide introduces Zabbix 6.2’s latest features—including issue suppression, CyberArk vault integration, AWS EC2 templates, and enhanced proxy management—then provides a comprehensive, command‑line walkthrough for installing and configuring Zabbix 6.2 on a CentOS 8 server, covering prerequisites, database setup, web UI, and service startup.
When you need a file of a specific size for testing or troubleshooting on Linux, you can use the dd, truncate, or fallocate commands to generate large files efficiently without manually writing data.
OpenCloudOS, a community‑driven Linux distribution, combines full‑stack hardware support, autonomous supply‑chain control, and extensive performance optimizations to deliver a high‑availability, cloud‑native server OS that rivals CentOS while offering 99.999% uptime and up to 50% performance gains in real‑world workloads.
This article provides a comprehensive overview of the Linux kernel, explaining its core responsibilities, memory and process management, device drivers, system calls, and security, followed by detailed guidance on kernel modules, common commands such as uname, lsmod, modinfo, modprobe, depmod, and practical steps for compiling and configuring the kernel.
This article introduces a highly recommended open‑source Nginx visualization project, outlines its core features such as configuration management and performance monitoring, provides step‑by‑step installation and deployment instructions for Linux, and shares the source code location along with remaining challenges.
This guide explains Linux performance fundamentals—including throughput, latency, average load, CPU context switching, memory management, swap behavior, and the essential monitoring tools such as vmstat, pidstat, perf, and strace—while providing concrete command examples and troubleshooting steps.
Linux will start supporting the Rust programming language from kernel version 6.1, adding about 12,500 lines of code, with ongoing work from the Rust‑for‑Linux community, GCC’s Rust front‑end integration, and early driver examples demonstrating Rust’s potential in kernel development.
This guide walks through the four essential stages of a Linux system’s startup—BIOS POST, the GRUB2 bootloader, kernel initialization, and systemd—explaining each step, the commands used to inspect targets, and how the process culminates in the user login prompt.
This article explains core components of the Linux kernel network stack, including the sk_buff packet buffer, net_device interfaces for physical and virtual NICs, the relationship between socket and sock structures, layer transitions, Netfilter hooks, and routing via dst_entry, providing a comprehensive overview for developers.
This guide introduces the most frequently used Linux command‑line tools, explaining what each command does, its basic syntax, and common options, so newcomers can quickly perform file management, system inspection, and networking tasks across any Linux distribution.
This guide introduces Nushell, a Rust‑written cross‑platform shell, explains its core goals, and provides step‑by‑step installation commands for Ubuntu/Debian, RHEL, macOS, Docker, and how to set it as the default user shell.
This article explains the PCIe architecture, the host's depth‑first enumeration process across buses, bridges and endpoints, demonstrates Linux lspci commands for inspecting devices, and details how PCIe memory accesses enable NVMe command submission and completion.
This guide reviews the top free remote‑desktop clients for Ubuntu and other Linux distributions, explains their protocol support, provides simple installation commands (including Flatpak), and highlights both open‑source and commercial options for various use cases.
Learn how systemd replaces traditional init on modern Linux, its key features, command syntax, unit file structure, and step-by-step hands-on examples that show how to create and control systemd services for Nginx, Tomcat, and custom Java JAR applications using systemctl.
The article examines whether today’s powerful operating systems can assume tasks traditionally handled by database kernels, tracing the evolution from early OS‑dependent databases to modern systems that leverage OS file cache, VMM, and storage optimizations, while also discussing scenarios where direct DB control remains necessary.
This guide explains how to enable and configure Linux firewall ports on CentOS 7 using firewalld and on CentOS 6 using iptables, covering status checks, opening specific ports, reloading rules, and common troubleshooting tips such as service listening verification.
This article explains step by step how a simple Hello World program is compiled, linked, and executed on Linux, covering the ELF executable format, the role of the file command, the fork‑execve process creation sequence, and the kernel’s binary loader implementation.
This guide explains how to use tcpdump for capturing and filtering network packets on Linux, covering basic usage, interface selection, host and port filters, protocol-specific captures, combined expressions, limiting capture size, saving to files, and a practical troubleshooting scenario with nginx and Node.js.
This guide explains how to set and read Linux environment variables, presents six practical methods for configuring PATH—including using export, editing ~/.bashrc, ~/.bash_profile, /etc/bashrc, /etc/profile, and /etc/environment—details their scope and persistence, and analyzes the system's variable‑loading order with testing scripts.
This article explains the distinction between user and kernel space, outlines the steps involved in a process switch, and compares several Linux I/O models—including blocking, non‑blocking, multiplexing, and asynchronous approaches—highlighting their advantages and drawbacks.
This article explains the concepts of virtual memory, kernel and user modes, DMA, and why data must move between kernel and user spaces, then compares standard I/O with zero‑copy techniques, MMAP, and off‑heap buffers, showing how they reduce copy operations and improve Java server performance.
This article explains TCP fundamentals—including connection-oriented design, byte‑stream transmission, reliability, header structure, flag meanings, the three‑way handshake, four‑way termination, SYN‑Flood attacks, time‑wait handling, retransmission strategies, kernel tuning parameters, Nagle’s algorithm, and congestion control mechanisms such as slow start and congestion avoidance.
This article explains the fundamentals of Linux shell operation, detailing how commands are processed, the role of the shell, user and group permissions, file types, symbolic and octal permission representations, and practical commands like chmod, chown, chgrp, and umask for managing access control.
This article explains how the Linux shell works as an interface to the kernel, describes user and group concepts, details file types and permission representations, and provides step‑by‑step guidance on using chmod, chown, chgrp, umask, and sticky bits to manage access control.
Although Linux is widely regarded as secure, the prevalence of web servers on the platform makes it a target for malware, so this guide reviews the most effective Linux antivirus tools, their key features, and how to install and use them.
This article provides a comprehensive overview of Zabbix, an open‑source, web‑based monitoring solution, detailing its architecture, key features, monitoring principles, core components, default ports, and step‑by‑step instructions for deploying both the server and agent on Linux systems.
Discover five powerful Linux system‑monitoring alternatives to htop—atop, vtop, btop++, Glances, and nmon—each with unique features, visual styles, and straightforward installation commands for popular distributions.
This guide shows how to install ImageMagick on CentOS 8, use the convert command to change image formats, batch‑process files with a Bash script, rotate or flip images, append pictures, and resize them, providing practical command‑line examples and tips.
Linus Torvalds recently reminded Linux kernel contributors that the development schedule for the upcoming 6.1 release, including rc8 and the final version, will overlap with the Christmas holidays, urging developers to finalize pull requests and avoid last‑minute bugs before the festive break.
Notepad Next is a cross‑platform, open‑source code editor built with Qt5 that offers many of Notepad++'s features on Linux, Windows, and macOS, and can be installed via Flatpak or AppImage with simple commands.
