BestHub
Sign in
Tagged articles
121 articles
Page 1 of 2
James' Growth Diary
James' Growth Diary
May 13, 2026 · Backend Development

How Claude Code Bridges IDEs: Local IPC Meets Remote WebSocket

The article dissects Claude Code's bridge architecture, explaining how a local IDE extension communicates with a CLI via Unix domain sockets while a remote web UI talks to the same process through a WebSocket‑SSE‑polling fallback, and it details the three worker models, three‑layer transport downgrade, four‑layer authentication, the FlushGate pattern, observability design, and the trade‑offs and costs of this 31‑file system.

AuthenticationFlushGateIDE bridge
0 likes · 17 min read
How Claude Code Bridges IDEs: Local IPC Meets Remote WebSocket
James' Growth Diary
James' Growth Diary
May 8, 2026 · Artificial Intelligence

How Claude Code’s Agent Swarms Use Unix Domain Sockets to Run 10 AIs Concurrently

This article deep‑dives into Claude Code’s Agent Swarms, explaining why Unix Domain Sockets replace HTTP for intra‑process communication, how three‑stage address parsing, filesystem‑based mailbox queues, various spawn modes, AgentId design, graceful shutdown, plan‑mode approval and common pitfalls together enable reliable, low‑latency coordination of multiple LLM agents.

Agent SwarmsClaude CodeIPC
0 likes · 14 min read
How Claude Code’s Agent Swarms Use Unix Domain Sockets to Run 10 AIs Concurrently
Deepin Linux
Deepin Linux
Feb 20, 2026 · Fundamentals

Unlocking Zero‑Copy: How Linux Shared Memory Boosts IPC Performance

This article explains the fundamentals of Linux memory management, details how shared memory implements zero‑copy inter‑process communication, and provides step‑by‑step code examples of system calls, mmap, sendfile, splice, and synchronization techniques for high‑performance data transfer.

IPCMemory ManagementZero Copy
0 likes · 40 min read
Unlocking Zero‑Copy: How Linux Shared Memory Boosts IPC Performance
Deepin Linux
Deepin Linux
Feb 2, 2026 · Fundamentals

Mastering Linux IPC: Pipes, Message Queues, Shared Memory, Semaphores, Signals & Sockets Explained

This comprehensive guide breaks down Linux inter‑process communication (IPC) by explaining its core concepts, why it’s needed, and detailing six mechanisms—pipes, named pipes, message queues, shared memory, semaphores/PV operations, signals, and sockets—complete with code samples, diagrams, and real‑world usage scenarios.

C programmingIPCLinux
0 likes · 49 min read
Mastering Linux IPC: Pipes, Message Queues, Shared Memory, Semaphores, Signals & Sockets Explained
Deepin Linux
Deepin Linux
Jan 4, 2026 · Fundamentals

Unlocking Linux Shared Memory: Deep Dive into IPC Mechanics and Implementation

This article thoroughly explains Linux shared memory, covering its advantages over other IPC methods, the kernel data structures, virtual‑physical mapping, creation and destruction APIs, copy‑on‑write behavior, and provides complete example code for inter‑process communication.

C programmingIPCMemory Management
0 likes · 46 min read
Unlocking Linux Shared Memory: Deep Dive into IPC Mechanics and Implementation
Deepin Linux
Deepin Linux
Oct 30, 2025 · Fundamentals

Unlocking Linux Kernel‑User Communication: How Netlink Bridges the Gap

This article explains how Linux’s Netlink mechanism provides efficient, full‑duplex communication between kernel space and user space, overcoming the limitations of ioctl, /proc, and system calls, and details its architecture, data structures, API usage, and real‑world applications.

IPCKernelLinux
0 likes · 45 min read
Unlocking Linux Kernel‑User Communication: How Netlink Bridges the Gap
Deepin Linux
Deepin Linux
Sep 15, 2025 · Fundamentals

Unlock Linux IPC: Deep Dive into Pipes, Signals, Shared Memory and More

This comprehensive guide explores Linux inter‑process communication (IPC), explaining why processes need to communicate, the underlying kernel mechanisms, and detailed coverage of pipes, FIFOs, signals, files, shared memory, message queues, and sockets with practical code examples and real‑world use cases.

IPCLinuxSockets
0 likes · 48 min read
Unlock Linux IPC: Deep Dive into Pipes, Signals, Shared Memory and More
AndroidPub
AndroidPub
Jul 24, 2025 · Mobile Development

Master Android IPC: Services, AIDL, Intents, Broadcasts, Messenger, FileProvider

This guide explores Android's inter‑process communication options—running services in separate processes, defining AIDL interfaces, using explicit and implicit Intents, BroadcastReceiver, Messenger, FileProvider, and ContentProvider—detailing configuration, code examples, and when to choose each method for efficient, secure component interaction.

AIDLAndroidBroadcastReceiver
0 likes · 11 min read
Master Android IPC: Services, AIDL, Intents, Broadcasts, Messenger, FileProvider
Liangxu Linux
Liangxu Linux
Jun 24, 2025 · Fundamentals

Why HarmonyOS’s Microkernel Isn’t Linux Yet Runs Linux Apps

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
Why HarmonyOS’s Microkernel Isn’t Linux Yet Runs Linux Apps
Liangxu Linux
Liangxu Linux
May 26, 2025 · Fundamentals

How Pipes, Named Pipes, and Message Queues Revolutionized Process Communication

From early 1970s Bell Labs' breakthrough of process isolation to the invention of in‑memory pipes, named pipes, and structured message queues, this article traces the evolution of inter‑process communication, highlighting design motivations, code structures, advantages, limitations, and the performance challenges that drove each innovation.

IPCOperating SystemsProcess Communication
0 likes · 8 min read
How Pipes, Named Pipes, and Message Queues Revolutionized Process Communication
Linux Code Review Hub
Linux Code Review Hub
May 20, 2025 · Fundamentals

Why HarmonyOS Microkernel Can Run Linux and Emulate Linux Containers

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
Why HarmonyOS Microkernel Can Run Linux and Emulate Linux Containers
Liangxu Linux
Liangxu Linux
Mar 12, 2025 · Fundamentals

Master Linux Inter‑Process Communication: Pipes, Signals, Shared Memory, and More

This article provides a comprehensive guide to Linux inter‑process communication (IPC), covering pipes, named pipes, signals, file‑based communication, semaphores, various shared‑memory techniques, message queues, sockets, and Unix domain sockets, each explained with concepts, typical use‑cases, diagrams and complete C code examples.

IPCInterprocess CommunicationLinux
0 likes · 32 min read
Master Linux Inter‑Process Communication: Pipes, Signals, Shared Memory, and More
Linux Kernel Journey
Linux Kernel Journey
Feb 17, 2025 · Fundamentals

Master Linux Interprocess Communication and End Process Isolation Issues

This article explains why Linux processes need to communicate, describes the kernel‑mediated IPC framework, compares shared‑memory and message‑passing approaches, and provides detailed code examples for pipes, FIFOs, signals, files, semaphores, sockets, plus real‑world use cases and case studies.

C programmingIPCInterprocess Communication
0 likes · 31 min read
Master Linux Interprocess Communication and End Process Isolation Issues
Java Tech Enthusiast
Java Tech Enthusiast
Jan 25, 2025 · Fundamentals

Understanding Network Ports and Their Role in Web Services

Network ports are numeric endpoints that let operating systems direct traffic to the correct service, with standard values like 80 for HTTP, 443 for HTTPS, 22 for SSH, and others such as 3306 for MySQL, enabling developers to configure custom ports while browsers often hide these defaults for user convenience.

Backend DevelopmentIPCTCP/IP
0 likes · 17 min read
Understanding Network Ports and Their Role in Web Services
Liangxu Linux
Liangxu Linux
Dec 11, 2024 · Fundamentals

Master Linux Inter‑Process Communication: Pipes, Signals, Shared Memory & More

This guide explains Linux inter‑process communication (IPC) mechanisms—including anonymous and named pipes, signals, file‑based communication, semaphores, various shared‑memory techniques, message queues, TCP/UDP sockets, and Unix domain sockets—providing concepts, typical use cases, and complete C code examples for each method.

IPCLinuxmessage queues
0 likes · 32 min read
Master Linux Inter‑Process Communication: Pipes, Signals, Shared Memory & More
Liangxu Linux
Liangxu Linux
Dec 7, 2024 · Fundamentals

How Does a Keystroke Travel From Keyboard to Your Screen?

This article explains step‑by‑step how a key press is detected by the keyboard controller, generates an interrupt, is handled by the kernel driver, written to a device file, and finally delivered to an X Window client via IPC.

IPCKeyboardOS fundamentals
0 likes · 4 min read
How Does a Keystroke Travel From Keyboard to Your Screen?
Deepin Linux
Deepin Linux
Nov 7, 2024 · Fundamentals

Comprehensive Overview of Embedded Interview Topics, Web Server Basics, TCP/IP Model, Linux Memory Management, and IPC

This article provides a detailed, English-language overview of interview self‑introduction tips, web server concepts and challenges, the TCP/IP four‑layer model, Linux virtual and physical memory management, malloc allocation strategies, and the differences between process and thread communication mechanisms.

IPCLinuxTCP/IP
0 likes · 27 min read
Comprehensive Overview of Embedded Interview Topics, Web Server Basics, TCP/IP Model, Linux Memory Management, and IPC
Linux Kernel Journey
Linux Kernel Journey
Nov 3, 2024 · Fundamentals

Linux Kernel Source Walkthrough: The Five Core Subsystems

This article explains the Linux kernel architecture, breaks it into three layers and five key subsystems—process scheduling, memory management, virtual file system, network interface, and inter‑process communication—detailing their responsibilities, inter‑dependencies, and providing concrete code examples and diagrams.

IPCKernelLinux
0 likes · 29 min read
Linux Kernel Source Walkthrough: The Five Core Subsystems
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Oct 11, 2024 · Backend Development

Understanding VS Code's IPC Architecture and Channel Mechanism

This article explains VS Code's inter‑process communication (IPC) architecture, detailing how preload scripts expose methods, how the main process creates Server, Connection, and Channel classes, how the renderer creates a Client to connect, and how ProxyChannel converts services to typed channels, with full TypeScript code examples.

Backend DevelopmentElectronIPC
0 likes · 11 min read
Understanding VS Code's IPC Architecture and Channel Mechanism
Java Tech Enthusiast
Java Tech Enthusiast
Sep 20, 2024 · Backend Development

What Is RPC and Why It Is Not a Protocol

The article clarifies that RPC (Remote Procedure Call) is a mechanism—not a protocol—used to abstract network communication so remote methods can be invoked like local calls, illustrating its design with LPC, dynamic proxies, request handlers, and showing HTTP as one possible implementation.

Backend DevelopmentDistributed SystemsIPC
0 likes · 6 min read
What Is RPC and Why It Is Not a Protocol
Code Mala Tang
Code Mala Tang
Sep 11, 2024 · Backend Development

Master Node.js Child Processes: exec, spawn, fork & IPC Explained

This guide explains the Node.js child_process module, covering its purpose, the four creation methods (exec, execFile, spawn, fork), how to handle output streams, inter‑process communication, best‑practice management tips, and when to choose child processes over worker threads.

IPCNode.jschild_process
0 likes · 14 min read
Master Node.js Child Processes: exec, spawn, fork & IPC Explained
OPPO Amber Lab
OPPO Amber Lab
Jul 22, 2024 · Information Security

Exploiting AIDL and Parcelable Mismatches in Android IPC

This article examines how mismatched read/write implementations in Android's Parcelable and AIDL mechanisms create exploitable IPC vulnerabilities, outlines several historical bug patterns, and discusses potential attack vectors and mitigation strategies.

AIDLAndroidIPC
0 likes · 11 min read
Exploiting AIDL and Parcelable Mismatches in Android IPC
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Jul 12, 2024 · Mobile Development

In-depth Analysis of Android Binder IPC Mechanism (Android 14 & Kernel 6.1)

This article walks through Android Binder IPC on Android 14 and Linux 6.1, detailing client‑side service registration and lookup, the kernel driver’s handling of parcels, reference management, and how ServiceManager maps names to IBinder objects, culminating in a diagram of the full native‑to‑kernel transaction flow.

AndroidAndroid14Binder
0 likes · 22 min read
In-depth Analysis of Android Binder IPC Mechanism (Android 14 & Kernel 6.1)
FunTester
FunTester
Jun 3, 2024 · Backend Development

Implementing Unix Domain Socket Communication in Java with junixsocket

This article demonstrates how to use the junixsocket library to add Unix domain socket support to Java applications, providing Maven dependency details, full server and client code examples, and cross‑language testing with a Go server implementation.

BackendIPCJava
0 likes · 6 min read
Implementing Unix Domain Socket Communication in Java with junixsocket
FunTester
FunTester
May 27, 2024 · Backend Development

Understanding Unix Domain Sockets and a Go Implementation

This article explains Unix domain sockets as a high‑performance inter‑process communication mechanism, describes their types and workflow, outlines advantages and typical use cases, and provides a complete Go example of a server and client communicating via a Unix socket.

Backend DevelopmentGoIPC
0 likes · 7 min read
Understanding Unix Domain Sockets and a Go Implementation
Liangxu Linux
Liangxu Linux
Mar 28, 2024 · Fundamentals

Why Do Web Services Need Ports? Understanding the Hidden Layer Behind URLs

Ports act as an essential indirection layer that maps network requests to specific processes, enabling protocols like HTTP and HTTPS to function, while default ports simplify user interaction; this article explains common ports, default values, the role of IPC, naming services, and how ports embody inversion of control principles.

IPCNetworkingSoftware Architecture
0 likes · 18 min read
Why Do Web Services Need Ports? Understanding the Hidden Layer Behind URLs
Deepin Linux
Deepin Linux
Mar 14, 2024 · Fundamentals

Process Concepts, Principles, and Management in Operating Systems

This article explains the definition, characteristics, and structure of processes, describes process creation, termination, and state transitions, outlines various scheduling algorithms, and introduces inter‑process communication mechanisms such as pipes, sockets, shared memory, and message queues, with example C code for Linux.

C programmingIPCLinux
0 likes · 31 min read
Process Concepts, Principles, and Management in Operating Systems
Deepin Linux
Deepin Linux
Mar 7, 2024 · Fundamentals

Understanding Linux mmap: Memory Mapping, Shared Memory, and IPC Mechanisms

This article explains Linux's mmap mechanism, its relationship with shared memory, the advantages and disadvantages of mmap versus traditional shared memory, and provides practical code examples and detailed steps for using mmap in interprocess communication and large‑file handling.

IPCLinuxVirtual Memory
0 likes · 19 min read
Understanding Linux mmap: Memory Mapping, Shared Memory, and IPC Mechanisms
Sohu Tech Products
Sohu Tech Products
Jan 24, 2024 · Mobile Development

Advanced Android Binder Interview Questions and Answers

This guide presents advanced Android Binder interview questions and concise answers, covering its architecture, cross‑process communication, relationship with AIDL, object lifecycle and death notifications, thread‑pool mechanics, performance tuning for large data transfers, and security measures, equipping engineers for confident interview performance.

AIDLAndroidBinder
0 likes · 15 min read
Advanced Android Binder Interview Questions and Answers
Sohu Tech Products
Sohu Tech Products
Dec 27, 2023 · Mobile Development

Mac App Store Development: App Sandbox and Security Essentials

Developers targeting the Mac App Store must enable the mandatory App Sandbox and configure appropriate entitlements, privacy descriptions, and security‑scoped bookmarks to control file, hardware, network, and inter‑process access, while using App Groups, ATS, and supported IPC methods for secure, compliant macOS apps.

ATSApp GroupsApp Sandbox
0 likes · 12 min read
Mac App Store Development: App Sandbox and Security Essentials
Liangxu Linux
Liangxu Linux
May 17, 2023 · Fundamentals

Understanding Linux Kernel Synchronization: From Semaphores to Thread Pools

This article explains the various Linux kernel synchronization mechanisms—including inter‑process communication, semaphores, mutexes, message queues, shared memory, and thread pools—detailing how they work, when to use them, and their role in ensuring coordinated execution within the kernel.

IPCKernelLinux
0 likes · 10 min read
Understanding Linux Kernel Synchronization: From Semaphores to Thread Pools
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Jan 20, 2023 · Operations

Inside Android’s traced_perf: Architecture, IPC, and Unwinding Explained

This article provides an in‑depth technical walkthrough of Android’s traced_perf component, covering its code layout, integration with Perfetto, IPC mechanisms, perf_event handling, sample acquisition, stack unwinding, and trace writing, while illustrating each step with diagrams and reference links.

Android profilingIPCLinux performance
0 likes · 21 min read
Inside Android’s traced_perf: Architecture, IPC, and Unwinding Explained
Taobao Frontend Technology
Taobao Frontend Technology
Jan 17, 2023 · Backend Development

Unlocking Node.js Child Process Communication with NODE_CHANNEL_FD

This article explains how Node.js uses the NODE_CHANNEL_FD environment variable to establish a socketpair for IPC between a parent process and its child, detailing the spawn implementation, underlying libuv handling, and how a Go subprocess can read and write through the shared file descriptor.

Backend DevelopmentGoIPC
0 likes · 9 min read
Unlocking Node.js Child Process Communication with NODE_CHANNEL_FD
php Courses
php Courses
Nov 28, 2022 · Backend Development

Using PHP shmop Functions for Shared Memory: Overview and Practical Examples

This article explains PHP's two shared memory interfaces, shm and shmop, details the primary shmop functions, provides code examples for creating, reading, writing, and deleting shared memory segments, demonstrates testing with Linux commands, and includes a practical class‑based usage example.

IPCLinuxPHP
0 likes · 9 min read
Using PHP shmop Functions for Shared Memory: Overview and Practical Examples
21CTO
21CTO
Sep 24, 2022 · Frontend Development

Why Wails Is the Lightweight Go Alternative to Electron for Desktop Apps

This article explains how the Go‑based Wails framework provides a lightweight, fast, and native‑rendered solution for cross‑platform desktop applications, comparing it to Electron and detailing its features, IPC mechanism, and the recent v2 release.

Desktop AppsElectron AlternativeGo
0 likes · 6 min read
Why Wails Is the Lightweight Go Alternative to Electron for Desktop Apps
vivo Internet Technology
vivo Internet Technology
Aug 3, 2022 · Frontend Development

Desktop Development with Electron: Technology Selection, Build Process, Performance Optimization, Quality Assurance, and Security

The guide details selecting Electron for cross‑platform desktop apps, then outlines a TypeScript‑Vue‑Vite stack with pnpm‑Turbo, explains build and packaging strategies, performance tweaks, update mechanisms, automated testing, crash handling, and layered security measures including native Rust modules and source‑code protection.

Desktop DevelopmentElectronIPC
0 likes · 19 min read
Desktop Development with Electron: Technology Selection, Build Process, Performance Optimization, Quality Assurance, and Security
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Jul 29, 2022 · Information Security

How Android’s Binder Uses SELinux to Enforce Secure IPC Permissions

This article examines Android’s Binder inter‑process communication mechanism, detailing how SELinux integrates with the /dev/binder driver, the role of ServiceManager as ContextManager, the definition of binder‑related permissions, and the kernel‑level security hooks that enforce SEAndroid checks during binder transactions.

AndroidBinderIPC
0 likes · 20 min read
How Android’s Binder Uses SELinux to Enforce Secure IPC Permissions
Java Architect Essentials
Java Architect Essentials
Apr 17, 2022 · Frontend Development

How Xunlei’s Electron Client Manages Multi‑Window IPC and Download SDK

This article dissects the Xunlei (Thunder) desktop client built with Electron, revealing how its front‑end resources are packaged, how multiple BrowserWindow instances communicate via a custom IPC server, and how the DownloadSDK is integrated through a Node addon, complete with code excerpts and process diagrams.

DownloadSDKElectronIPC
0 likes · 11 min read
How Xunlei’s Electron Client Manages Multi‑Window IPC and Download SDK
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Oct 18, 2021 · Frontend Development

Mastering Electron IPC: From Hello World to Secure Desktop Apps

This guide walks you through the fundamentals of Electron, explaining what it is, its capabilities, how to set up a project, create windows, manage lifecycle events, implement preload scripts, and establish robust inter‑process communication (IPC) between the main and renderer processes with practical code examples.

BrowserWindowDesktop AppElectron
0 likes · 18 min read
Mastering Electron IPC: From Hello World to Secure Desktop Apps
Douyu Streaming
Douyu Streaming
Sep 27, 2021 · Game Development

Douyu’s Live2D Virtual Avatar Plugin: Unity Architecture & Key Tech

This article details Douyu's virtual avatar tool built on Unity and Live2D, covering project background, core features, layered architecture, key technologies such as Unity rendering, FairyGUI UI, TCP-based IPC, model dressing and recoloring, face‑data processing, and future development plans.

Game DevelopmentIPCLive2D
0 likes · 13 min read
Douyu’s Live2D Virtual Avatar Plugin: Unity Architecture & Key Tech
Sohu Tech Products
Sohu Tech Products
Aug 18, 2021 · Mobile Development

Android Four Major Components Communication Process and Interaction with ActivityManagerService

This article provides a comprehensive, macro-level analysis of Android's four core components—Activity, Service, BroadcastReceiver, and ContentProvider—detailing how each interacts with the ActivityManagerService (AMS) through Binder IPC, including code examples for startActivity, startService, bindService, broadcast, and ContentProvider operations across processes.

ActivityManagerServiceAndroidBinder
0 likes · 20 min read
Android Four Major Components Communication Process and Interaction with ActivityManagerService
Top Architect
Top Architect
Jul 13, 2021 · Backend Development

Inter‑Process Communication in Microservices: Interaction Styles, API Design, Evolution, and Failure Handling

This article explains how microservices communicate via inter‑process communication, covering interaction patterns (one‑to‑one, one‑to‑many, synchronous and asynchronous), API definition and evolution, strategies for handling partial failures, and the choice of messaging or request/response technologies such as REST and Thrift.

BackendIPCrest
0 likes · 19 min read
Inter‑Process Communication in Microservices: Interaction Styles, API Design, Evolution, and Failure Handling
ELab Team
ELab Team
Jun 9, 2021 · Backend Development

Mastering Node.js Multi‑Process Architecture: Fork, Cluster, and IPC Explained

This article explains how Node.js handles processes, demonstrates creating child processes with fork, illustrates inter‑process communication (IPC) using send and message events, explores handle passing and shared ports, and shows how to build robust clusters with the built‑in cluster module.

ClusterIPCNode.js
0 likes · 11 min read
Mastering Node.js Multi‑Process Architecture: Fork, Cluster, and IPC Explained
58 Tech
58 Tech
May 21, 2021 · Backend Development

Designing High‑Concurrency Systems with PHP Object Pooling and Swoole IPC

The article explains the core idea of pooling to trade space for time, analyzes the shortcomings of in‑process connection pools in PHP‑FPM, proposes long‑connection and cross‑process pooling solutions using Swoole’s IPC mechanisms, and demonstrates significant CPU and latency improvements in a real‑world high‑concurrency backend.

Connection PoolingIPCPHP
0 likes · 9 min read
Designing High‑Concurrency Systems with PHP Object Pooling and Swoole IPC
Open Source Linux
Open Source Linux
Feb 6, 2021 · Cloud Native

How Pods Communicate: Shared Volumes and IPC in Kubernetes

This article explains the four Kubernetes networking models and demonstrates two primary ways for containers inside a Pod to exchange data—using shared volumes and inter‑process communication (IPC)—with detailed YAML examples and command‑line verification steps.

Container CommunicationIPCKubernetes
0 likes · 7 min read
How Pods Communicate: Shared Volumes and IPC in Kubernetes
Liangxu Linux
Liangxu Linux
Dec 22, 2020 · Fundamentals

Mastering Processes and Threads: 19 Essential OS Concepts Explained

This comprehensive guide covers the fundamentals of processes and threads, their definitions, relationships, creation, lifecycle, scheduling strategies, context switching, inter‑process communication methods, and practical C/C++ examples, providing a deep dive into operating‑system concepts for developers and interview preparation.

C++IPCLinux
0 likes · 41 min read
Mastering Processes and Threads: 19 Essential OS Concepts Explained
ITPUB
ITPUB
Dec 17, 2020 · Fundamentals

How Linux Pipes, FIFOs, and Signals Enable Interprocess Communication

This article explains the fundamentals of Linux pipes and named pipes (FIFOs), their kernel implementation, read/write APIs with code examples, and an overview of signal mechanisms, types, and handling in the context of inter‑process communication.

C programmingIPCLinux
0 likes · 15 min read
How Linux Pipes, FIFOs, and Signals Enable Interprocess Communication
Liangxu Linux
Liangxu Linux
Dec 14, 2020 · Fundamentals

How Linux Pipes and Signals Work Under the Hood

This article explains the internal workings of Linux pipes, named pipes (FIFOs), and signal handling, covering their kernel implementation, synchronization mechanisms, relevant system calls, and provides concrete C code examples for creating and using these inter‑process communication primitives.

IPCLinuxnamed pipe
0 likes · 17 min read
How Linux Pipes and Signals Work Under the Hood
Liangxu Linux
Liangxu Linux
Dec 9, 2020 · Fundamentals

Master Linux Pipes and Redirection: A Hands‑On Guide with Code Examples

This article explains the fundamentals of Linux pipes and file redirection, covering their definitions, how they work as inter‑process communication mechanisms, how to create and use them in C with pipe(), dup2() and fork(), and how to redirect standard streams using freopen(), all illustrated with clear code snippets and diagrams.

C programmingIPCLinux
0 likes · 8 min read
Master Linux Pipes and Redirection: A Hands‑On Guide with Code Examples
Liangxu Linux
Liangxu Linux
Aug 12, 2020 · Fundamentals

Why Microkernels Can Beat Monolithic Kernels: A Deep Dive with C Simulations

The article examines the performance drawbacks of traditional monolithic kernels, especially IPC overhead, and argues that microkernel designs using arbitration can reduce lock contention, supported by C code simulations and benchmark graphs that compare execution time, CPU utilization, and scalability across thread and CPU counts.

IPCMonolithic KernelOperating System
0 likes · 19 min read
Why Microkernels Can Beat Monolithic Kernels: A Deep Dive with C Simulations
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 24, 2020 · Fundamentals

Common Interprocess Communication Methods in Linux

This article introduces several Linux interprocess communication mechanisms—including pipes, message queues, shared memory, semaphores, signals, and sockets—explaining their principles, advantages, drawbacks, and typical usage scenarios for developers preparing for system‑level programming or interviews.

IPCLinuxSockets
0 likes · 7 min read
Common Interprocess Communication Methods in Linux
Liangxu Linux
Liangxu Linux
Jul 16, 2020 · Fundamentals

Demystifying Linux Processes, Threads, IPC, and Scheduling

This article provides a comprehensive overview of Linux fundamentals, covering process and thread concepts, the fork and exec system calls, various inter‑process communication mechanisms, memory layout, scheduling algorithms such as O(1) and CFS, synchronization primitives, and the boot sequence, all illustrated with code snippets and diagrams.

IPCLinuxScheduling
0 likes · 34 min read
Demystifying Linux Processes, Threads, IPC, and Scheduling
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Mar 20, 2020 · Backend Development

Optimizing Data Transfer in Swoole 4.5: Reducing Memory Copies Between Master and Worker Processes

This article analyzes the performance bottleneck in Swoole 4.5 where the master process copies data twice before delivering it to worker processes, explains the underlying C functions and data flow, and presents two code‑level optimizations that consolidate buffers and eliminate redundant copies, resulting in a four‑fold speedup of the onMessage callback.

IPCPHPSwoole
0 likes · 17 min read
Optimizing Data Transfer in Swoole 4.5: Reducing Memory Copies Between Master and Worker Processes
58 Tech
58 Tech
Mar 9, 2020 · Mobile Development

In‑Depth Overview of Android Binder IPC Mechanism

This article provides a comprehensive introduction to Android's Binder inter‑process communication mechanism, covering its background, design principles, performance, stability and security advantages over traditional IPC, detailed Linux IPC concepts, the Binder driver architecture, proxy pattern, and hands‑on code examples for manual implementation.

AIDLAndroidBinder
0 likes · 24 min read
In‑Depth Overview of Android Binder IPC Mechanism
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Jan 17, 2020 · Mobile Development

Understanding Android Binder IPC: Service Manager Startup, Client Registration, and Core Data Structures

The article explains Android’s Binder IPC mechanism, detailing how the Service Manager starts during boot, how client processes locate and register services via binder_proc, binder_thread, and binder_node structures, and describing the kernel’s transaction handling, memory mapping, and allocator data structures that enable efficient inter‑process communication.

AndroidBinderIPC
0 likes · 18 min read
Understanding Android Binder IPC: Service Manager Startup, Client Registration, and Core Data Structures
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Dec 27, 2019 · Mobile Development

Why Android Uses Binder: Deep Dive into Its IPC Architecture

This article explains Android's Binder IPC framework, covering its layered architecture, the reasons behind its design—including object reference management, performance, stability, and security—and details the software and communication protocols that enable inter‑process communication on the platform.

AndroidBinderIPC
0 likes · 17 min read
Why Android Uses Binder: Deep Dive into Its IPC Architecture
Python Crawling & Data Mining
Python Crawling & Data Mining
Oct 21, 2019 · Fundamentals

Master Python Multiprocessing: From Fork to Process Pools

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.

IPCPythonThread
0 likes · 15 min read
Master Python Multiprocessing: From Fork to Process Pools
WecTeam
WecTeam
Oct 11, 2019 · Frontend Development

How to Build a JSON Editor with Electron: From Setup to Production

This article walks through creating a GUI‑based JSON editor for the Social Cube platform using Electron, covering environment setup, dual webpack configurations, IPC communication, data persistence with Dexie, real‑time file syncing, context menus, logging, packaging with electron‑builder, and update handling, all illustrated with code snippets.

Desktop AppDexieElectron
0 likes · 23 min read
How to Build a JSON Editor with Electron: From Setup to Production
Architects' Tech Alliance
Architects' Tech Alliance
Oct 7, 2019 · Backend Development

Inter‑Process Communication Patterns and API Design for Microservices

This article explains how microservices, unlike monolithic applications, rely on inter‑process communication mechanisms, describes various interaction styles, API definition and evolution, handling partial failures, and compares synchronous (REST, Thrift) and asynchronous (messaging) IPC technologies.

IPCMessagingMicroservices
0 likes · 18 min read
Inter‑Process Communication Patterns and API Design for Microservices
Seewo Tech Circle
Seewo Tech Circle
Jun 28, 2019 · Frontend Development

Building a Fast, Updatable PC Client with Electron for Classroom Interaction

This article details how a team of web developers chose Electron to create a cross‑platform PC client for the teaching tool "Classroom Optimization Master", describing the technology stack, successive architectural evolutions, performance improvements, and lessons learned about modular design and hot updates.

Desktop ApplicationElectronIPC
0 likes · 13 min read
Building a Fast, Updatable PC Client with Electron for Classroom Interaction
MaGe Linux Operations
MaGe Linux Operations
Jun 27, 2019 · Backend Development

Master Python Multiprocessing: Fork, Process, Pool, and IPC Explained

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
Master Python Multiprocessing: Fork, Process, Pool, and IPC Explained