This guide explains how Linux window managers can maximize screen real estate, improve multitasking, and enhance desktop aesthetics, covering popular tiling managers such as bspwm, Qtile, herbstluftwm, Awesome, IceWM, i3, Sway, and xmonad, with installation commands and key considerations for Xorg and Wayland.
This guide walks you through installing K9s on Windows, Linux, and Docker, explains its core features like XRay, Pulse, and Popeye, and provides essential hot‑key shortcuts for efficient Kubernetes cluster management using a terminal UI.
This article explains why allocating 8 GB of memory on a 4 GB Linux system can succeed or fail depending on the OS bitness, the overcommit_memory setting, and whether swap is enabled, illustrated with C code experiments, virtual‑memory diagrams, and detailed analysis of OOM handling.
This comprehensive guide walks you through the most frequently used Linux commands—including pwd, cd, tree, mkdir, touch, ls, cp, mv, rm, rmdir, ln, readlink, find, xargs, rename, basename, dirname, chattr, lsattr, file, md5sum, chown, chmod and umask—detailing their purpose, syntax, common options, and practical examples to help you navigate and manage the command line efficiently.
After fifteen years of using Linux exclusively, the author shares a detailed, experience‑driven guide on adapting to Windows 10, covering desktop chaos, limited customisation, missing Unix‑style tools, software installation hurdles, terminal upgrades, automatic restarts, virtual desktops, clipboard differences, and practical workarounds.
The article explains the purpose of the SSH known_hosts file, how it stores remote host public keys to prevent man‑in‑the‑middle attacks, and provides step‑by‑step commands for adding, updating, bypassing, and removing entries, as well as tips for managing multiple users and retrieving host details.
The article explains the traditional Linux read/write system‑call I/O path, detailing the multiple CPU and DMA copies, context switches, page‑cache mechanisms, and advanced techniques such as zero‑copy, multiplexing, and direct I/O for performance optimization.
This guide walks through preparing two CentOS VMs, installing Nginx, explaining high‑availability concepts, and configuring Keepalived with VRRP and a health‑check script to achieve automatic failover of Nginx services via a virtual IP.
This article explains the Linux kernel limits that determine how many files and TCP connections a server can open, describes the key parameters (fs.file-max, soft nofile, fs.nr_open), shows configuration examples, and discusses how memory, ports, and other settings affect real‑world capacity for both servers and clients.
This article explains Keepalived’s inner workings, covering its integration with LVS/IPVS, the VRRP election protocol, key configuration parameters, load‑balancing algorithms, and practical deployment examples to help engineers build reliable high‑availability services.
This article introduces Alibaba DataX, explains its architecture and role in offline heterogeneous data synchronization, provides step‑by‑step Linux installation, demonstrates full‑load and incremental MySQL‑to‑MySQL sync with JSON job templates, and shares practical tips for handling large data volumes.
The 2022 Stack Overflow Developer Survey reveals that Linux surpassed macOS as the preferred operating system for both personal and professional use among developers, driven by open‑source appeal, cloud growth, and improved desktop experiences, while Windows remains the overall leader.
This article explains Linux's virtual address space layout, the six user‑space memory segments, how malloc decides between brk and mmap based on allocation size, the behavior of free, and why both allocation methods are needed for performance and memory management.
This guide explains how to install, configure, and run a lightweight Redis Monitor that visualizes connection count, QPS, memory usage and replication delay, supports standalone, sentinel and cluster modes, and provides email and WeChat alerts via simple PHP scripts.
This article outlines the fundamental differences between Unix and Linux, covering shell defaults, option styles, make utilities, compiler conventions, GNU versus Linux distinctions, and the trademarked UNIX term, helping developers write portable scripts and build systems across various Unix-like platforms.
This guide explains the advantages of cgroup v2 over v1, outlines the Linux distribution and kernel requirements, and provides detailed, command‑line instructions for enabling cgroup v2 on Debian, configuring kubelet and containerd, and updating monitoring tools for Kubernetes clusters.
This guide explains what Linux environment variables are, how to display them with env or printenv, set new variables using export, make them read‑only, unset them, access them from C programs with getenv/setenv/unsetenv, and modify system configuration files to persist changes.
This article explains how Linux file systems represent file size versus actual disk usage, demonstrates the difference between Size and Blocks using du and stat, describes inode and multi‑level block indexing, and shows why copying a sparse 100 GB file with cp finishes in a fraction of a second.
This article provides a comprehensive overview of Linux fundamentals, covering the kernel's memory and process management, the virtual file system, device drivers, network stack, shell variants, file types, directory hierarchy, disk partitioning, mounting procedures, and link mechanisms, all illustrated with practical command examples.
This guide lists six Linux networking commands that have been deprecated—ifconfig, netstat, scp, route, egrep/fgrep, and arp/iptunnel/nameif—and shows the modern ip, ss, sftp/rsync, and grep alternatives with usage examples and brief explanations.
This article explains the Linux kernel parameters that limit open files and TCP connections, shows how to increase those limits with sysctl and limits.conf, and estimates the maximum number of concurrent connections a server or client can support based on memory and port constraints.
This tutorial explains the difference between \r and \n, line buffering, and how to use fflush and usleep to create a live updating progress bar and countdown timer in a Linux C program, complete with multi‑file implementation and sample code.
Learn how to turn your Linux desktop into a full‑featured gaming platform by installing and running GOG Windows games using Lutris or Heroic Games Launcher, with detailed instructions on selecting Wine/Proton versions, configuring runners, connecting your GOG library, and troubleshooting common issues.
This guide explains how logrotate automates log rotation, detailing its configuration files, common directives such as rotate, daily, size, compress, postrotate, and sharedscripts, and provides practical examples for managing large log files efficiently on Linux servers.
This guide walks through the most common Linux compression formats—.zip, .gz, .bz2, .tar.gz, and .tar.bz2—detailing their syntax, practical command examples, and how to compress, decompress, and inspect archives efficiently from the terminal.
This article compiles common Docker interview questions and provides detailed explanations, covering Docker fundamentals, use cases, advantages, differences from virtual machines, core components, installation steps, storage configuration, image management, container creation, networking modes, data volumes, private registry setup, backup procedures, and MySQL deployment, all illustrated with practical command examples.
This guide walks you through eight essential NGINX configuration adjustments—including worker processes, connection limits, GZIP compression, timeout values, buffer sizes, logging, static content caching, and open file caching—to maximize web server performance on Linux systems.
This guide explains what crontab does, its syntax and options, provides practical examples, highlights typical problems such as environment variables, time misconfiguration, special characters and output redirection, and offers debugging tips and tools for reliable Linux task scheduling.
This article explains what eBPF is, why it matters for cloud‑native architectures, its key components and use‑cases in networking, observability and security, and explores current market momentum and commercialization models for leveraging eBPF in modern infrastructure.
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.
