Tagged articles
fork
69 articles · Page 1 of 1
A community-driven fork of Deno called Ende removes all Node.js and npm compatibility layers, retaining only Web standards and a native Ende namespace, while facing immediate ecosystem friction when third-party libraries like Hono still depend on Node.js built-ins such as async_hooks.
DenoEndeJSR
0 likes · 8 min read

Claude Code’s v2.1.212 overhaul turns /fork into a one‑click “clone” that spawns an independent background session with full conversation memory, letting you fix bugs or run long jobs while your primary work continues uninterrupted.
AI automationClaude CodeSubAgent
0 likes · 8 min read


21CTOJul 19, 2026 · Industry Insights
After Linus Torvalds said developers opposed to AI‑generated patches can fork the kernel, a community member created the NoAI Linux branch that strips all AI code, outlines strict contribution rules, and sparks varied reactions across the open‑source ecosystem.
AILinuxcommunity
0 likes · 6 min read

The article traces Vim’s rise as the world’s most ubiquitous Unix text editor, Bram Moolenaar’s solitary 32‑year maintenance and charitable model, the rejected multithreading patch that birthed Neovim, subsequent community splits, AI‑code debates, and recent feature milestones, illustrating how open‑source governance evolved after his death.
AI-generated codeNeovimVim
0 likes · 11 min read

This article dissects Claude Code's AgentTool, explaining how it spawns full‑featured sub‑agents, routes execution through three distinct paths, shares Anthropic Prompt Cache via Fork, and protects against infinite recursion with a dual‑layer safeguard while isolating worktrees for safe parallel file operations.
AI toolingAgentToolClaude Code
0 likes · 13 min read

Long Claude Code sessions quickly become noisy as every grep, find, and ls call stays in the main context, but using sub‑agents—including the built‑in Explore and Plan agents and the CLAUDE_CODE_FORK_SUBAGENT flag—isolates work, returns only concise summaries, and lets you monitor activity with a context‑timeline hook.
Claude CodeExplorePlan
0 likes · 7 min read

This article explains the fork system call in the Linux kernel, details the copy‑on‑write (COW) mechanism that underpins its efficiency, provides code examples, and explores practical scenarios and performance implications for process creation, memory usage, and concurrent server programming.
COWLinuxProcess Management
0 likes · 36 min read

This article demystifies Linux's fork, exec, and copy‑on‑write mechanisms, explaining their inner workings, performance trade‑offs, and how they cooperate during typical command execution, while providing clear code examples and practical insights for developers and interview preparation.
COWLinuxProcess Management
0 likes · 38 min read

This article provides a comprehensive, step‑by‑step explanation of Linux process management, covering the definition of a process, PCB structure, task organization, state transitions, creation system calls (fork, vfork, clone), execution with exec, scheduling, waiting, termination, and the kernel’s resource allocation strategies.
LinuxProcess Managementexec
0 likes · 43 min read

This tutorial explains core Linux process concepts—including the difference between programs and processes, how to view and identify processes, detailed usage of fork and vfork for creating child processes, process termination, zombie and orphan handling, and practical examples of exec, system, and popen functions with C code.
Linuxc-programmingexec
0 likes · 28 min read

This article explains Linux process concepts, creation methods like fork, vfork and clone, termination handling, and the inner workings of the Completely Fair Scheduler (CFS), including virtual runtime, red‑black tree organization, priority changes, and wake‑up compensation.
CFSLinuxfork
0 likes · 42 min read

This guide explains Linux processes, the role of the Process Control Block, how processes are created with fork and exec, the differences between foreground, background and daemon processes, and provides practical command‑line tools such as ps, top, htop, pgrep, pkill, kill, killall, pidof, nice and renice for effective process monitoring and control.
LinuxProcess Managementdaemon
0 likes · 25 min read

This article explains how the fork() system call creates a duplicate process in Linux, walks through a simple code experiment, details the kernel steps—including task_struct creation, PID allocation, copy-on-write memory handling, and resource inheritance—and highlights common use cases, optimizations, and pitfalls.
C++Linuxcopy-on-write
0 likes · 12 min read

This article explains how Linux processes are created, managed, and replaced using the fork, wait (including waitpid), and exec system calls, covering their prototypes, return values, copy‑on‑write optimization, and practical C code examples that demonstrate their coordinated use in real‑world scenarios.
Linuxc-programmingexec
0 likes · 25 min read

This article explains what ELF files are, details their header, program header table, sections and section header table, and walks through how Linux uses fork and execve to clone a child process and load an ELF binary into a new address space.
Binary FormatELFLinux
0 likes · 13 min read

This article introduces tcpw, a small eBPF‑based utility that traces TCP, UDP, and Unix‑domain sockets to display the five‑tuple of commands like curl or telnet, explains its command‑line options, shows concrete usage examples, and details the underlying BPF and Go implementation, including connect, accept, and fork tracing.
GoLinux tracingaccept
0 likes · 8 min read

An in‑depth guide explains what a program and a process are, details the Linux task_struct fields, describes process states, creation functions like fork, vfork, clone, kthread_create, the do_fork core, copy‑on‑write, termination methods, and the roles of zombie, orphan, and init processes.
Linuxforkos
0 likes · 20 min read

This article provides a comprehensive overview of Linux process management, covering fundamental concepts such as tasks and states, the internal task_struct representation, process creation via fork/vfork/clone, execution with execve, lifecycle transitions, scheduling policies, copy‑on‑write optimization, resource limits, and practical tools for monitoring and controlling processes.
COWLinuxProcess Management
0 likes · 67 min read

This article walks through the Linux kernel mechanisms for creating and destroying processes, covering copy‑on‑write, the fork/vfork/clone system calls, the kernel_clone implementation in kernels 5.0 and 6.5, the copy_process workflow, and the steps the kernel takes to wake up a new task and clean up a terminated one.
CloneLinuxeBPF
0 likes · 26 min read

This article explains the Linux zombie process concept, shows how they are created when a parent neglects wait(), demonstrates the issue with sample C code and ps output, discusses the risks of PID exhaustion, and provides proper handling techniques using wait() and process reaping.
Linuxforkwait
0 likes · 7 min read

This article explains how Linux creates processes using fork, vfork, clone and pthread_create, reveals the role of the init process, explores clone flags and namespace checks in the kernel, and shows why understanding these fundamentals demystifies container startup.
Linuxcontainerfork
0 likes · 7 min read

Researchers from Truffle Security revealed that GitHub's delete function often fails to truly remove data, exposing a new Cross Fork Object Reference (CFOR) vulnerability that allows anyone with a commit hash to access deleted or private repository data, posing serious security risks.
CFORGitHubcommit hash
0 likes · 11 min read


21CTOFeb 17, 2024 · Backend Development
Maxim Dounin launched the FreeNginx fork to free the popular Nginx web server from F5's corporate influence after disputes over an HTTP/3 vulnerability, highlighting broader geopolitical and open‑source governance challenges.
HTTP/3NGINXbackend development
0 likes · 6 min read

This tutorial walks you through Linux process creation with fork, explains copy‑on‑write mechanics, details process termination, waiting, and program replacement using exec families, and culminates in building a basic shell, complete with code examples and visual illustrations.
Linuxc-programmingexec
0 likes · 42 min read

This article walks through a simple C program that forks a parent and child process, explains why they share the same virtual address for a global variable yet see different values, and details how Linux uses virtual memory, page tables, and copy‑on‑write to manage process address spaces.
copy-on-writeforkprocess
0 likes · 10 min read

This article explains Linux process creation and termination, covering kernel functions like kernel_thread, kthread_create, kthread_run, the central _do_fork implementation, and user‑space interfaces such as fork, vfork, and pthread_create, with code snippets and diagrams.
Linuxforkkernel
0 likes · 7 min read

This guide explains how to identify and resolve Redis performance degradation by measuring baseline latency, checking slowlog, avoiding high‑complexity commands, handling big keys, managing expiration spikes, tuning memory limits, reducing fork overhead, disabling huge pages, configuring AOF, binding CPUs, preventing swap usage, fixing memory fragmentation, and using lazy‑free mechanisms.
AOFBigKeyMemory
0 likes · 35 min read

This article explains Redis's three persistence options—Append‑Only File (AOF), Redis DataBase snapshots (RDB), and the hybrid mode—detailing their inner workings, configuration strategies, performance trade‑offs, and how to choose the most reliable solution for a given workload.
AOFRDBdatabase
0 likes · 23 min read

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.
Linuxc-programmingexec
0 likes · 25 min read

This article provides a deep, step‑by‑step exploration of Linux process creation, using Nginx’s worker forking as a concrete example, and walks through the task_struct layout, process states, PID management, address‑space handling, file system structures, namespaces, and the internal logic of the fork system call.
Linuxforkkernel
0 likes · 23 min read

This article explains how to add a daemon flag to a Rust server, showing two implementations—one using the fork crate and another using the daemonize crate—so the service can keep running after the shell exits.
DaemonizeRustbackend development
0 likes · 6 min read

This article explains how Linux implements processes and threads, showing that both are represented by the same task_struct structure, detailing thread creation via pthread_create and clone, and comparing the kernel‑level steps—including flag handling, copy_process, and resource sharing—that differentiate threads from full processes.
CloneLinuxThread
0 likes · 17 min read

This article explains the Von Neumann computer architecture, the role of the operating system, process creation and control blocks, various process states, priority and nice values, as well as virtual address spaces and their relationship to physical memory, using Linux examples and diagrams.
Linuxforkmemory management
0 likes · 22 min read

The article analyzes a recurring one‑second pause in a Redis 4.0 master‑slave setup, identifies the periodic BGSAVE fork operation as the root cause through metrics like latest_fork_usec, and presents mitigation strategies such as memory limits, activedefrag, and migration to a lower‑RSS instance.
BGSAVEforkmemory fragmentation
0 likes · 6 min read

This tutorial explains Linux process concepts, how to view and identify processes, the differences between programs and processes, and provides detailed examples of using fork, vfork, wait, exec family functions, system, and popen to create, control, and monitor child processes, including handling zombies and orphans.
System Programmingexecfork
0 likes · 29 min read

This article explains the copy‑on‑write mechanism in Linux by examining page‑table structures, the fork process, and the page‑fault handling code in Linux 0.11, illustrating how the kernel uses read‑only page mappings and page‑fault interrupts to lazily duplicate memory pages.
Linuxcopy-on-writefork
0 likes · 9 min read

A Linux server repeatedly reports “fork: cannot allocate memory” not because RAM is exhausted but due to excessive Java threads causing PID allocation failures, and the kernel mistakenly maps those failures to the ENOMEM error code.
ENOMEMalloc_pidfork
0 likes · 12 min read

This guide explains why GitHub lacks an unfork feature, outlines the problems caused by forked repositories, and provides a step‑by‑step method using GitHub Support (with optional command‑line cloning) to detach a fork while preserving commit history and fork records.
GitGitHubRepository
0 likes · 3 min read

This article analyzes why Linux reports "fork: cannot allocate memory" when the real issue is an excessive number of threads or PID allocation failures, explains the kernel's do_fork and alloc_pid implementations, and offers guidance for diagnosing and fixing such misleading ENOMEM errors.
ENOMEMLinuxPiD
0 likes · 11 min read


ITPUBMar 9, 2022 · Fundamentals
The article explains why Linux’s fork() can return a misleading “fork: cannot allocate memory” error, tracing the issue to PID allocation failures in the kernel’s do_fork and alloc_pid functions, and shows how excessive threads, not actual memory shortage, trigger the problem.
ENOMEMLinuxPiD
0 likes · 12 min read

The article explains why Linux reports "fork: cannot allocate memory" when the real issue is PID allocation failure caused by excessive threads, analyzes the kernel's do_fork and alloc_pid implementations, and shows that newer kernels still return ENOMEM for non‑memory errors.
ENOMEMLinuxfork
0 likes · 13 min read

This article dissects the Linux kernel’s fork implementation, explaining why the child receives a return value of 0, how parent and child share code execution, the internal steps of sys_fork, kernel_clone, copy_process, thread handling, scheduling initialization, and the final insertion of the new task into the run‑queue.
LinuxSchedulingfork
0 likes · 10 min read

This guide explains what zombie processes are, how they are created when a child exits before its parent reaps it, and provides practical commands and sample C code to reproduce and safely remove zombie processes on a Linux system.
LinuxProcess Managementfork
0 likes · 7 min read

This step‑by‑step guide shows how to clone a forked GitHub repository, configure the upstream remote, fetch and merge upstream updates, resolve any conflicts, and push the synchronized code back to your fork, ensuring your local copy stays up to date.
GitGitHubfetch
0 likes · 8 min read

This article explains process and thread fundamentals, describes Node.js's single‑threaded nature, and provides detailed guidance on using the child_process module (spawn, fork, exec, execFile) and the cluster module to create, manage, and communicate between multiple Node.js processes for scalable, high‑concurrency applications.
BackendClusterNode.js
0 likes · 11 min read

This article explains PHP's pcntl_fork() function, how it creates child processes on Linux, the return values in parent and child, code examples demonstrating variable copying and process multiplication, and clarifies why a loop with three forks results in seven child processes.
LinuxPHPfork
0 likes · 3 min read

This article explains the concepts of processes, their identifiers, the fork system call, and the differences between orphan and zombie processes, providing code examples, output analysis, and practical ways to handle each situation on Unix‑like systems.
LinuxPiDfork
0 likes · 10 min read

This article explains what a process is, how it differs from a program, outlines its key characteristics, clarifies concurrency versus parallelism, describes how to create child processes, and covers orphan and zombie processes, termination methods, process groups, sessions, and race conditions.
Concurrencyforkoperating system
0 likes · 7 min read

This article explains Redis's two persistence mechanisms—RDB snapshot files and AOF append‑only logs—including their operation, configuration commands, advantages, disadvantages, recovery procedures, and performance recommendations for choosing between them.
AOFRDBdatabase
0 likes · 17 min read

This article explains how Redis implements two persistence mechanisms—RDB snapshots and AOF logs—covering their triggers, execution flows, advantages, drawbacks, differences, restart recovery procedures, and practical ways to mitigate performance overhead caused by fork operations.
AOFRDBdatabase
0 likes · 14 min read

This article explains what a Linux zombie process is, why it remains after a child exits, what information it retains, how it affects system resources, and provides a complete C example with compilation and command‑line steps to observe and clean up zombies.
Process Managementforkwaitpid
0 likes · 5 min read


21CTOOct 29, 2019 · Blockchain
This article provides a clear, beginner‑friendly explanation of blockchain as a decentralized distributed database, covering its essential structure, hash‑based immutability, mining difficulty, fork resolution, and why its practical use cases remain limited.
BlockchainHashMining
0 likes · 12 min read

This article explains the concepts of processes and threads in Python, compares multi‑process, multi‑thread, and combined approaches, shows how to use fork, the multiprocessing module, process pools, subprocesses, and inter‑process communication with queues, and provides complete code examples with results.
ConcurrencyIPCPython
0 likes · 15 min read

The article analyzes a rare blocking issue in a Python Agent where a subprocess created via subprocess.Popen hangs due to an unclosed pipe inherited by a forked child process, demonstrates debugging steps using thread frames and lsof, and provides a reproducible example and mitigation recommendations.
LinuxPipePython
0 likes · 10 min read

This article explains how to create and manage multiple processes in Python using the os.fork method, the multiprocessing module's Process and Pool classes, and demonstrates inter‑process communication with Queue and Pipe, providing clear code examples for both Unix/Linux and cross‑platform environments.
IPCPythonfork
0 likes · 10 min read

This guide walks through the complete workflow for contributing code to a GitHub project, covering forking, cloning, creating a development branch, committing changes, pushing them, opening a pull request, and synchronising a fork with upstream updates.
Clonefork
0 likes · 6 min read

This article explains Redis high‑availability concepts, focusing on persistence mechanisms—RDB snapshots and AOF logging—detailing their triggers, execution flows, file formats, configuration options, performance trade‑offs, and practical guidance for choosing and tuning persistence in production environments.
AOFConfigurationHigh Availability
0 likes · 29 min read

This article explains Bitcoin's transaction‑packaging process, the step‑by‑step mining workflow, the causes of blockchain forks—including both natural and intentional splits—and the criteria used to select the best chain as the main chain, providing a comprehensive technical overview.
BitcoinBlockchainConsensus
0 likes · 10 min read

This article explains why open‑source software is vital, defines what open source means, and provides a detailed, illustrated workflow—from forking a repository on GitHub to creating pull requests and merging code—so developers can start contributing effectively.
ContributionGitHubfork
0 likes · 7 min read

This article explains the detailed process of Bitcoin transaction packaging, the steps miners follow to create new blocks, and how both natural and intentional blockchain forks arise, including the criteria for selecting the best chain and the differences between hard and soft forks.
BitcoinBlockchainConsensus
0 likes · 11 min read


ITPUBJan 14, 2018 · Blockchain
This tutorial explains blockchain as a special distributed database, covering its core concepts such as block structure, hash immutability, mining difficulty, dynamic difficulty adjustment, and chain forks, while highlighting its advantages, limitations, and typical use cases like cryptocurrencies.
BlockchainHashMining
0 likes · 12 min read


ITPUBJan 6, 2018 · Blockchain
This article provides a clear, beginner‑friendly explanation of blockchain, covering its nature as a decentralized database, the role of blocks and hashes, mining mechanics, difficulty adjustment, and how forks are resolved, while highlighting both strengths and limitations of the technology.
BlockchainHashMining
0 likes · 13 min read


21CTOJan 5, 2018 · Blockchain
This article provides a clear, step‑by‑step explanation of blockchain fundamentals, covering its nature as a distributed database, key features like decentralization, block structure, hash immutability, mining processes, difficulty adjustment, forks, and practical limitations, all illustrated with diagrams.
difficultydistributed ledgerfork
0 likes · 12 min read

This article provides a clear, beginner‑friendly explanation of blockchain technology, covering its nature as a decentralized database, block structure, hashing, mining difficulty, dynamic adjustment, forks, and practical limitations, while illustrating concepts with diagrams and real‑world examples.
BlockchainHashMining
0 likes · 10 min read

This article explains the differences between exec, source, and fork in Bash, covering process creation, environment variable inheritance, command groups, variable substitution, positional parameters, logical operators, and provides example scripts to illustrate each concept for effective shell scripting.
_sourcecommand substitutionenvironment variables
0 likes · 26 min read


21CTOMar 29, 2016 · Databases
This article examines the various scenarios that cause Redis to block—such as expensive commands, fork‑induced overhead, and persistence operations—and provides practical architectural and configuration solutions to keep the event loop responsive even with large data volumes.
blockingforkoptimization
0 likes · 13 min read


ITPUBDec 29, 2015 · Backend Development
This tutorial walks you through creating a simple iterative Python web server, demonstrates its single‑request limitation, explains socket fundamentals, and then shows how to transform it into a concurrent server using the Unix fork() system call while handling backlog, duplicate descriptors, and zombie processes.
Socketsfile-descriptorsfork
0 likes · 18 min read

This article examines Node.js’s early criticisms about reliability and single‑threaded limits, then explains how the built‑in cluster module and fork() enable multi‑process deployment, load balancing, and communication, illustrated with code demos, performance insights, and a look at nginx proxy integration.
ClusterNGINXNode.js
0 likes · 9 min read

This article explains the differences between code, programs, and processes in Linux, demonstrates how to compile and run a simple program, explores parent‑child relationships, the role of the init process, the process lifecycle, and the copy‑on‑write mechanism.
Linuxcopy-on-writeexec
0 likes · 10 min read
