Inter-Process Communication (IPC)

Pipes are a unidirectional IPC channel, typically used for communication between a parent and child process. Data written to the write end is read from the read end. Named Pipes (or FIFOs) exist as a file in the filesystem, allowing unrelated processes to communicate.

• Anonymous Pipes: Created with the pipe() system call, exist only for the lifetime of the processes, and are usually used for related processes.
• Named Pipes (FIFOs): Created with mkfifo, have a persistent presence in the filesystem, enabling communication between any processes that know the pipe's name.
• Use Case: Pipes are classic in Unix/Linux for connecting the standard output of one command to the standard input of another (ls | grep). Named pipes are used for simple, persistent inter-process data streams.

Sockets are a generalized network IPC interface that can facilitate communication between processes on the same machine (Unix Domain Sockets) or across a network (Network Sockets using TCP/UDP). They provide a full-duplex, bidirectional communication channel.

• Unix Domain Sockets: Extremely efficient for local IPC, using the filesystem as a namespace for addressing.
• Network Sockets: Enable distributed systems. Protocols like TCP provide reliable, ordered delivery, while UDP offers connectionless, best-effort datagrams.
• Use Case: The backbone of networked applications, client-server architectures, and is the underlying transport for higher-level protocols like gRPC and WebSocket connections.

Remote Procedure Call (RPC) is a protocol that allows a program to execute a function or procedure on another address space (another process or machine) as if it were a local call. It abstracts the complexities of network communication.

• Mechanism: The client calls a local stub function, which marshals parameters into a message, sends it to the server, waits for the response, unmarshals it, and returns the result.
• Modern Implementations: Frameworks like gRPC (using HTTP/2 and Protocol Buffers) and JSON-RPC provide structured, efficient RPC.
• Use Case: Fundamental for building distributed systems, microservices, and client-agent interactions where a synchronous request-response semantic is required.

Semaphores and Mutexes are synchronization primitives, not data-transfer IPC mechanisms per se, but are critical for safe IPC. They control access to shared resources (like shared memory or a queue) to prevent race conditions.

• Semaphore: A counter used to control access to a pool of resources. Operations are wait() (decrement) and signal() (increment).
• Mutex (Mutual Exclusion): A binary lock that ensures only one thread or process can enter a critical section of code at a time.
• IPC Role: When using Shared Memory or any shared state, these primitives are mandatory to ensure data integrity and coordinated access between concurrent processes.

A Remote Procedure Call (RPC) is a protocol that allows a program to execute a procedure (subroutine) in another address space (often on a different machine) as if it were a local function call. It abstracts network communication into a familiar programming paradigm. Key implementations include:

• gRPC: Uses HTTP/2 and Protocol Buffers for high-performance, type-safe contracts.
• JSON-RPC: A lightweight protocol using JSON for serialization. RPC typically follows a synchronous request-response pattern.

Publish-Subscribe (Pub/Sub) is a messaging pattern where senders (publishers) categorize messages into topics without knowing the specific receivers. Receivers (subscribers) express interest in one or more topics and receive relevant messages asynchronously. This pattern enables broadcast communication and dynamic, many-to-many relationships. It is a core pattern in event-driven architectures and is often implemented by message brokers like Apache Kafka or Redis Pub/Sub.

Pipes are a unidirectional IPC channel, typically used for communication between a parent and child process. Data written to the write end is read from the read end. Named Pipes (or FIFOs) exist as a file in the filesystem, allowing unrelated processes to communicate. They provide a simple byte-stream interface but are generally less flexible than message queues or sockets for complex coordination.

Sockets provide a bidirectional communication endpoint, most commonly used for network communication between processes on different machines (Internet sockets), but also for communication on the same host (Unix domain sockets). They support multiple protocols (e.g., TCP for reliable streams, UDP for datagrams) and are the foundation for most networked IPC. WebSockets build upon this model to provide full-duplex communication over a single, long-lived TCP connection.