Communication Patterns
in Distributed Systems
Remote Procedure Call
Concept:
● RPC allows a program to cause a procedure (subroutine) to execute in another address space (commonly on another physical
machine).
Key Points:
● Synchronous communication: The client waits for the server to finish processing and return the result.
● Abstraction: It abstracts the details of the network communication, making remote calls appear like local calls.
● Languages: Protocols like JSON-RPC, XML-RPC, and implementations in gRPC, Thrift.
Example Use Case:
● A client application calling a function on a remote server to fetch user data.
Remote Procedure Call
Pros:
● Simplicity: Abstracts the complexities of network communication, making remote calls look like local calls.
● Language Agnostic: Various implementations (e.g., gRPC) support multiple programming languages.
● Standardization: Many well-established protocols and libraries.
Cons:
● Synchronous Nature: Can lead to blocking calls, which may affect performance if the remote service is slow or unresponsive.
● Tight Coupling: The client and server need to agree on the interface, which can make versioning and changes more difficult.
● Error Handling: Network issues and remote failures can complicate error handling.
Remote Method Invocation (RMI)
Concept:
● RMI is similar to RPC but is specific to Java. It allows objects to invoke methods on an object running in another Java Virtual
Machine (JVM).
Key Points:
● Object-Oriented: Supports the concept of remote objects and allows invoking methods on them.
● Built-in Java: Part of the Java standard library.
● Serialization: Java objects are serialized and deserialized during communication.
Example Use Case:
● A Java client invoking a method on a remote Java server to perform a calculation.
Remote Method Invocation (RMI)
Pros:
● Object-Oriented: Allows remote method calls on objects, integrating well with Java's object-oriented paradigm.
● Built-in Security: Provides built-in mechanisms for handling security.
● Ease of Use: Being a part of the Java standard library, it's easy to set up and use within Java applications.
Cons:
● Java-Specific: Tied to Java, making it less useful in polyglot environments.
● Complexity: Can be complex to debug and manage, especially with large distributed systems.
● Performance Overhead: Serialization and deserialization can add overhead.
Message Passing
Concept:
● Communication via message exchange where processes or objects send and receive messages.
Key Points:
● Asynchronous communication: Messages can be sent and received without blocking the sender.
● Loose coupling: Systems can be loosely coupled, as they do not need to know the details of each other.
● Message Queues: Systems like RabbitMQ, Kafka for managing messages.
Example Use Case:
● A microservice architecture where services communicate via a message broker like RabbitMQ.
Message Passing
Pros:
● Asynchronous Communication: Decouples sender and receiver, allowing for non-blocking communication.
● Scalability: Can handle a large number of messages efficiently, especially with message brokers.
● Fault Tolerance: Messages can be stored and retried in case of failures.
Cons:
● Complexity: Requires managing message queues and handling message delivery guarantees.
● Latency: Messages may experience delays depending on the broker's performance and load.
● State Management: Maintaining the state across distributed components can be challenging.
Shared Memory
Concept:
● Multiple processes share a common memory space and communicate by reading and writing to that memory.
Key Points:
● High speed: Direct memory access is faster than message passing.
● Synchronization needed: Requires mechanisms like semaphores or locks to prevent data races.
Example Use Case:
● A multi-threaded application where threads share a global variable for communication.
Shared Memory
Pros:
● Speed: Direct memory access is fast, offering high-performance communication.
● Simplicity: Simple to implement for local communication between processes.
Cons:
● Synchronization Issues: Requires careful synchronization to avoid data races and inconsistencies.
● Limited Scope: Generally limited to processes on the same machine.
● Scalability: Not suitable for large-scale distributed systems across multiple machines.
Publish Subscribe
Concept:
● A messaging pattern where senders (publishers) send messages without knowing the receivers (subscribers).
Key Points:
● Decoupled systems: Publishers and subscribers are decoupled from each other.
● Event-driven: Suitable for event-driven architectures.
● Topics: Messages are categorized into topics, and subscribers receive messages based on their subscriptions.
Example Use Case:
● A news service where different clients subscribe to different news topics.
Publish Subscribe
Pros:
● Decoupling: Publishers and subscribers are decoupled, allowing independent evolution.
● Scalability: Supports a large number of subscribers and can handle high message volumes.
● Flexibility: Suitable for dynamic and flexible systems where components can subscribe and unsubscribe at runtime.
Cons:
● Complexity: Managing topics, subscriptions, and message delivery can be complex.
● Latency: Can introduce delays, especially if there are many intermediaries or if the system is under heavy load.
● Reliability: Ensuring reliable message delivery in the face of network failures can be challenging.
Socket Programming
Concept:
● Low-level communication over a network using sockets.
Key Points:
● Flexibility: Allows custom protocols and fine-grained control over communication.
● Bidirectional: Supports two-way communication.
● TCP/UDP: Can use TCP for reliable communication or UDP for faster, connectionless communication.
Example Use Case:
● A chat application where clients communicate with each other using TCP sockets.
Socket Programming
Pros:
● Flexibility: Allows custom protocols and provides fine-grained control over communication.
● Efficiency: Direct communication can be very efficient with low overhead.
● Bidirectional: Supports two-way communication, making it suitable for interactive applications.
Cons:
● Complexity: Requires handling low-level details like connection management, data framing, and error handling.
● Development Time: More time-consuming to develop compared to higher-level abstractions.
● Security: Requires careful handling to avoid security vulnerabilities like buffer overflows and injection attacks.
Web Services (REST)
Concept:
● Web services enable communication over the web using standard protocols like HTTP.
Key Points:
● Interoperability: Can be used across different platforms and languages.
● REST: Uses standard HTTP methods and can use JSON, XML, etc.
Example Use Case:
● A RESTful API providing data to various client applications over HTTP.
Web Service REST - Pros and Cons
Pros:
● Interoperability: Can be used across different platforms and languages.
● Standardization: Established standards and protocols, making integration easier.
● Wide Adoption: Widely used and supported by many tools and frameworks.
Cons:
● Performance Overhead and Latency: Can be slower due to the use of text-based protocols (XML, JSON) and HTTP.
