Tagged articles
POSIX
43 articles · Page 1 of 1
This article outlines six fundamental differences between Unix and Linux, covering shell standards, command options, make implementations, C compilers, GNU vs Linux distinctions, and the UNIX trademark, with practical guidance for writing portable code.
BSDClangGCC
0 likes · 6 min read

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.
ANSI CC languageLinux
0 likes · 7 min read


ITPUBSep 17, 2026 · Backend Development
A JDK 26 commit replaced reading /proc with a Linux-specific clock_gettime bit manipulation, cutting ThreadMXBean.getCurrentThreadUserTime() latency from 11 µs to 279 ns (40x, 400x under contention), illustrating the "abstraction tax" of portable standards.
JDKLinux kernelOpenJDK
0 likes · 14 min read

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.
C++LinuxPOSIX
0 likes · 44 min read

This comprehensive guide explains why race conditions occur in Linux processes, explores the underlying concepts of critical sections and synchronization, and provides practical examples of atomic operations, mutexes, semaphores, condition variables, read‑write locks, and spinlocks to ensure safe concurrent programming.
C++MutexPOSIX
0 likes · 39 min read

This article explains the fundamentals of Linux thread stack memory, identifies why default stack sizes can cause waste or overflow in high‑concurrency scenarios, and provides practical techniques—including stack‑size tuning, code refactoring, and memory‑mapping—to reduce memory usage and improve service stability.
C++LinuxPOSIX
0 likes · 34 min read

This article explains what POSIX is, its history, the organizations behind it, how it shaped Linux's success, and why understanding system calls versus library functions is essential for writing portable software across Unix‑like operating systems.
LinuxOperating SystemsPOSIX
0 likes · 17 min read

This guide explains Linux thread fundamentals, covering definitions, differences from processes, user‑level vs kernel‑level models, creation and termination with pthread APIs, attribute settings, cancellation, cleanup, detaching, and scheduling policies, all illustrated with complete code examples.
LinuxPOSIXScheduling
0 likes · 18 min read

This article provides a comprehensive guide to Linux threads, covering fundamental concepts, the distinction between processes and threads, user‑level vs kernel‑level threading, thread creation and termination with POSIX APIs, attribute settings, cancellation, cleanup, detachment, scheduling policies, and practical code examples.
LinuxPOSIXpthread
0 likes · 17 min read

This article walks through the evolution of Linux timers—from the simple alarm() function, through setitimer() and POSIX timer APIs, to the modern timerfd interface—explaining their APIs, code examples, advantages, limitations, performance trade‑offs, and practical selection guidance for different projects.
AlarmC++Linux
0 likes · 16 min read

The article explains how HarmonyOS’s microkernel differs from Linux’s monolithic design, why it can still run Linux binaries through POSIX, ABI shim, and HDF layers, and what architectural choices enable high‑performance IPC, distributed operation, and deterministic scheduling.
ABI shimHarmonyOSIPC
0 likes · 12 min read

Although HarmonyOS uses a microkernel rather than a monolithic Linux kernel, it achieves Linux compatibility and container emulation through a combination of POSIX support, an ABI shim layer, high‑performance IPC/RPC mechanisms, and the Hardware Driver Framework, which together translate Linux calls into microkernel services.
ABI shimHardware Driver FrameworkHarmonyOS
0 likes · 13 min read

This article introduces the POSIX standard for portable multithreaded and network programming in C, explains thread creation, lifecycle, and synchronization mechanisms such as mutexes, semaphores and condition variables, and provides complete server‑client socket examples together with practical multithreaded file‑processing code and debugging tips.
C++MultithreadingPOSIX
0 likes · 23 min read

This article provides a comprehensive overview of POSIX threads, covering their architecture, creation, synchronization, attributes, scheduling policies, advantages, drawbacks, and real‑world examples such as mutex protection, barrier synchronization, and a cross‑platform network server implementation.
LinuxMultithreadingPOSIX
0 likes · 21 min read


21CTOOct 11, 2024 · Fundamentals
Apple’s macOS 15 Sequoia has become the latest officially certified UNIX® system, joining both Apple Silicon and x86‑64 entries, and the article explains the history of UNIX, POSIX standards, the XNU kernel’s BSD roots, and how these foundations shape modern macOS and iOS development.
POSIXUNIX certificationXNU kernel
0 likes · 8 min read

This article explains the POSIX standards, their role in providing portable Unix-like system interfaces, demonstrates network client‑server programming with POSIX sockets, analyzes key socket functions and the TCP three‑way handshake, and introduces POSIX named and unnamed semaphores with example code for synchronization and producer‑consumer patterns.
C++POSIXnetwork programming
0 likes · 26 min read

This article explains the differences between threads and processes in Linux, introduces the concept of POSIX signals, describes how signals are delivered and handled in multithreaded programs, and provides a complete C example demonstrating proper signal handling across threads.
C++LinuxMultithreading
0 likes · 5 min read

Learn the core principles of synchronization and mutual exclusion in multi‑process or multi‑threaded Linux environments, explore design concepts such as atomic operations and deadlock avoidance, and see complete POSIX‑thread code examples using semaphores, condition variables, mutexes and spinlocks.
LinuxMultithreadingMutex
0 likes · 8 min read

The article surveys the evolution of POSIX abstractions from the 1970s to the present, explains why hardware trends and modern workloads expose limitations of the CPU‑centric model, and argues that a new set of higher‑level interfaces is needed for future systems.
I/O abstractionsOperating SystemsPOSIX
0 likes · 25 min read

The talk from DataFun Summit 2023 explains how Baidu's CFS storage builds a trillion‑file‑scale distributed file system by revisiting file system fundamentals, POSIX limitations, historical storage architectures, and introducing a lock‑free metadata service with single‑shard primitives, data‑layout optimizations, and a simplified client‑centric architecture that achieves high scalability and performance.
CFSPOSIXcloud storage
0 likes · 31 min read

This article explains the limitations of the traditional Unix fork model, introduces POSIX threads as lightweight processes, details their data structures, core functions, creation, termination, synchronization primitives, attributes, and provides extensive C code examples for practical multithreaded programming on Linux.
POSIXc-programmingpthreads
0 likes · 22 min read

This article details Volcano Engine's edge cloud storage challenges, evaluates multiple storage solutions, and explains how JuiceFS was adopted to simplify workflows, boost read/write performance, and provide a cloud‑native, POSIX‑compatible system for large‑scale edge rendering workloads.
CephJuiceFSKubernetes
0 likes · 14 min read

Although Linux is often called a Unix‑like system, it differs in several fundamental ways such as the default shell, command‑line option styles, make utility capabilities, C compiler defaults, GNU tool availability, and the trademarked UNIX designation, all of which affect portability and script writing.
C compilerGNULinux
0 likes · 6 min read

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.
GCCLinuxOperating Systems
0 likes · 5 min read

This article explains the limitations of the traditional Unix fork model, introduces lightweight POSIX threads as a faster alternative, and provides a comprehensive guide to thread creation, attributes, synchronization primitives, and cleanup functions using the pthread library in Linux.
LinuxMultithreadingPOSIX
0 likes · 17 min read

This article outlines the fundamental differences between Linux and Unix, covering topics such as the non‑standard Bash shell, the absence of long‑option support in Unix, variations in Make and C compilers, the distinction between GNU and Linux, and the trademarked UNIX name, providing a concise guide for developers navigating these operating systems.
C compilerLinuxOperating Systems
0 likes · 6 min read

This tutorial walks through Linux file programming fundamentals, covering how to open, create, read, write, and manipulate file descriptors and cursor positions with system calls like open, creat, read, write, lseek, and close, and demonstrates practical examples such as implementing a cp command, editing configuration files, and using both low‑level and standard C library I/O functions.
File I/OPOSIXc-programming
0 likes · 28 min read

Wine 6.14, the latest version of the open‑source compatibility layer that runs Windows applications on POSIX systems, introduces a Mono engine upgrade to 6.3.0, a new 32‑to‑64‑bit thunk in WOW64 DLLs, expanded GDI system call support, and resolves 30 known bugs affecting games and professional software.
Compatibility LayerGDIPOSIX
0 likes · 2 min read

This article explains the Linux I/O stack, the flow of data from user‑space buffers through libc buffers, page cache, and kernel buffers to the physical disk, covering functions like fwrite, fflush, fsync, O_DIRECT, scheduling algorithms, consistency issues, and performance considerations.
FilesystemI/OLinux
0 likes · 12 min read

The article warns that using the vague term “user” in software design creates security flaws and conceptual confusion, illustrated with ticket‑booking, Unix, and SaaS examples, and advises defining precise concepts like “team” and “member” early to avoid costly redesigns.
POSIXSaaSTerminology
0 likes · 7 min read

The article provides a comprehensive overview of the Lustre parallel file system architecture, its core components, POSIX compliance, scalability, high‑performance networking, security features, data layout mechanisms, and performance considerations for large and small files, along with practical optimization tips for HPC environments.
HPCLustrePOSIX
0 likes · 17 min read

This article explains the concepts of reentrant and thread‑safe functions, their differences, how signals affect them, examples of non‑reentrant scenarios, and practical guidelines for writing safe code in C on Unix-like systems.
POSIXSignal Handlingc-programming
0 likes · 14 min read


ITPUBJun 12, 2019 · Fundamentals
This article explains the principles of Linux shared memory interprocess communication, details the relevant data structures and system limits, walks through the essential API calls for creating, controlling, attaching, and detaching shared memory, and provides a full C program demonstrating parent‑child communication.
IPCInterprocess CommunicationLinux
0 likes · 7 min read


21CTOJun 6, 2019 · Fundamentals
This article traces the origins of Unix from the 1960s AT&T Bell Labs project, explains how Linux emerged from the GNU initiative and Linus Torvalds' kernel, and compares their philosophies, licensing, ecosystem, and current relevance across servers, cloud, embedded devices, and modern development.
BSDLinuxOperating Systems
0 likes · 12 min read

The article provides a comprehensive overview of the Lustre file system, detailing its cluster storage architecture, core components, scalability, performance optimizations, security mechanisms, high‑availability features, and usage in high‑performance computing environments.
HPCLustrePOSIX
0 likes · 14 min read

The article examines the recurring bugs and reliability issues in Linux file systems—especially ext4—highlighting Linus Torvalds' criticism, POSIX shortcomings, fuzz‑testing results, historical bug statistics, and practical advice for developers to avoid data‑loss pitfalls.
Data ReliabilityEXT4Linux
0 likes · 11 min read

Minoca OS, a fully from‑scratch, open‑source operating system released under GPL‑v3, targets low‑power, memory‑constrained devices with a modular driver model, package manager, and POSIX compatibility, and the project invites community contributions to expand its ecosystem and improve usability.
EmbeddedPOSIXmodular
0 likes · 8 min read


ITPUBOct 25, 2016 · Fundamentals
This article explains the POSIX requirements for signals in multithreaded Linux programs, details the kernel structures such as task_struct and signal_struct that enable shared signal handling, and walks through the key code paths—including copy_signal, copy_sighand, __send_signal, tkill/tgkill, and group exit—that manage signal delivery and thread‑group termination.
LinuxPOSIXSignals
0 likes · 12 min read

This article explains how Linux implements threads, contrasting traditional process definitions with lightweight processes, detailing the evolution from the early linuxthreads library to the modern NPTL implementation, and exploring POSIX requirements, thread groups, signal handling, and the experimental NGPT model.
LinuxNPTLPOSIX
0 likes · 10 min read


ITPUBJul 8, 2016 · Fundamentals
This article explains how Linux implements POSIX signal handling in multithreaded applications, detailing the relationship between signals and threads, the kernel structures like task_struct, signal_struct, and how signals are delivered, blocked, and cause group exits within a thread group.
LinuxPOSIXSignals
0 likes · 15 min read

This article explains why the infamous rm -rf / command is blocked by modern POSIX‑compliant coreutils, shows the exact error messages, details version requirements, and demonstrates how the dangerous --no-preserve-root option can override the safety guard.
LinuxPOSIXcommand safety
0 likes · 6 min read

This article explains Linux asynchronous I/O (AIO), compares it with synchronous and non‑blocking I/O models, describes the underlying aiocb structure, and provides detailed examples of the AIO API functions such as aio_read, aio_write, aio_error, aio_return, aio_suspend, aio_cancel and lio_listio.
AIOPOSIXSystem Programming
0 likes · 22 min read

This article explains how Linux device drivers use signal‑driven asynchronous I/O to notify applications, details the required driver and user‑space code, and walks through the POSIX AIO API functions and their integration with kernel drivers.
AIOLinuxPOSIX
0 likes · 13 min read
