BestHub
Sign in
Tagged articles

IPC

127 articles · Page 1 of 2
IT Learning Made Simple
IT Learning Made Simple
Aug 22, 2026 · Fundamentals

Superscalar vs Superpipeline: The Hidden Tricks Accelerating CPUs

The article explains how superscalar pipelines execute multiple instructions per cycle and how superpipelines increase clock frequency by adding more stages, compares their trade‑offs, shows historical evolution, and describes how modern CPUs combine both techniques along with out‑of‑order execution to boost IPC while facing power and complexity challenges.

CPUIPCmicroarchitecture
0 likes · 9 min read
Superscalar vs Superpipeline: The Hidden Tricks Accelerating CPUs
Deepin Linux
Deepin Linux
Jul 16, 2026 · Fundamentals

Why STL Containers Crash in Linux Shared Memory: Underlying Causes Explained

The article analyzes why placing STL containers such as std::map, std::string, or std::vector directly in Linux shared memory leads to segmentation faults, detailing memory continuity, cross‑process pointer invalidation, and lifecycle issues, and then presents safe alternatives like fixed‑size arrays, manual memory management, and Boost.Interprocess.

C++IPCLinux
0 likes · 17 min read
Why STL Containers Crash in Linux Shared Memory: Underlying Causes Explained
IT Learning Made Simple
IT Learning Made Simple
Jul 2, 2026 · Operations

Process View: The Heartbeat of System Runtime

The article explains the process view, which reveals how a system operates at runtime, covering processes, threads, inter‑process communication, concurrency models, synchronization mechanisms, performance indicators, and design principles, illustrated with diagrams and a concrete e‑commerce case study.

ConcurrencyIPCPerformance
0 likes · 9 min read
Process View: The Heartbeat of System Runtime
Thought Artisan
Thought Artisan
Jul 1, 2026 · Mobile Development

Android 17 Binder Observability: Lock-Free Observer V2 & Kernel Netlink Events

Android 17 enhances Binder observability with a lock-free SPSC queue, boot-stable sharding, exponential latency histograms, and CPU sampling in the user-space Observer V2, while introducing a kernel Netlink channel for asynchronous, zero-overhead IPC error events like frozen transactions and spam detection.

Android 17BinderIPC
0 likes · 8 min read
Android 17 Binder Observability: Lock-Free Observer V2 & Kernel Netlink Events
Deepin Linux
Deepin Linux
Jun 20, 2026 · Fundamentals

Why Using Pipes Can Max Out Your CPU: Hidden Costs and Fixes

Although Linux pipes avoid disk I/O and seem faster, misuse such as tiny frequent writes, mismatched read/write speeds, non‑blocking tight loops, and improper fd handling can drive a single core to 100 % CPU, but the article explains the underlying reasons and step‑by‑step optimizations to prevent it.

CPU usageIPCLinux
0 likes · 17 min read
Why Using Pipes Can Max Out Your CPU: Hidden Costs and Fixes
IT Services Circle
IT Services Circle
May 27, 2026 · Fundamentals

Why Can’t We Build a 10 GHz CPU Even with Liquid‑Helium Cooling?

Despite record overclocks reaching 9.2 GHz using liquid‑helium cooling, fundamental physical limits—quadratic power‑voltage scaling, exponential heat growth, signal‑propagation delay, and quantum tunnelling leakage—prevent mainstream CPUs from reliably operating at 10 GHz, prompting designers to focus on IPC and architectural efficiency instead of raw clock speed.

CPUIPCfrequency limits
0 likes · 12 min read
Why Can’t We Build a 10 GHz CPU Even with Liquid‑Helium Cooling?
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 managementshared memory
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.

IPCLinuxNetlink
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.

IPCProcess Communicationmessage queues
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.

IPCTCP/IPWeb Services
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.

IPCLinuxVFS
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.

ElectronIPCInterprocess Communication
0 likes · 11 min read
Understanding VS Code's IPC Architecture and Channel Mechanism
Linux Kernel Journey
Linux Kernel Journey
Sep 21, 2024 · Fundamentals

Synchronizing Linux Shared Memory IPC: Semaphores, Mutexes, and Condition Variables (with Code)

The article explains how to ensure data correctness in Linux inter‑process shared memory communication by using synchronization mechanisms—semaphores, mutexes, and condition variables—providing step‑by‑step code examples for each method and discussing their proper initialization, usage, and potential pitfalls.

C++Condition VariableIPC
0 likes · 15 min read
Synchronizing Linux Shared Memory IPC: Semaphores, Mutexes, and Condition Variables (with Code)
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.

IPCRPCRemote Procedure Call
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.

GoIPCInterprocess Communication
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.

IPCTCPnetworking
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.

IPCLinuxkernel
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 profilingIPCPerfetto
0 likes · 21 min read
Inside Android’s traced_perf: Architecture, IPC, and Unwinding Explained
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.

Electron alternativeGoIPC
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.

ElectronIPCPerformance Optimization
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.

BrowserWindowElectronIPC
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.

IPCLive2DStreaming
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.

IPCNode.jschild_process
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.

High ConcurrencyIPCPHP
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.

ConcurrencyIPCMicrokernel
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