Distributed Application Development and Middleware (DARM) 2023/2024 Semester 1

Constantine 2- Abdelhamid Mehri University

Semester 1 2023-2024

Chapter 3: Programming Models for Distributed Applications

Pedagogy Staff
Nom Grade Faculté/Institut Adresse e-mail
KITOUNI Ilham MCA Nouvelles Technologies Ilham.kitouni@univ-constantine2.dz

Merniz Amina MCB Nouvelles Technologies amina.merniz@univ-constantine2.dz

Merniz Amina MCB Nouvelles Technologies amina.merniz@univ-constantine2.dz

Dr KITOUNI Ilham 1
Distributed Application Development and Middleware (DARM) 2023/2024 Semester 1

Content:

• Client server architecture

• Message passing Model
• Remote procedure Call
• Distributed Objects
• Agent based programming
• Comparison
• Case studies

Examples

• Some examples of programming models for distributed applications:

o Message passing: MPI, Pthreads
o Distributed objects: Java RMI, CORBA
o Agent-based programming: JADE, MASON

Client-server Architecture
In the world of distributed application development, one of the most commonly used
architectures is the client-server architecture. This architecture consists of two main
components: the client and the server. The client is responsible for sending requests
to the server, while the server is responsible for processing those requests and sending
back the appropriate responses.
The client-server architecture is based on the principle of separation of concerns. The
client is concerned with the presentation layer, which includes the user interface and
user interactions. On the other hand, the server is concerned with the business logic
and data storage. This separation allows for a clear division of responsibilities, making
it easier to develop, maintain, and scale distributed applications.

Key characteristics of client-server architecture

There are several key characteristics that define the client-server architecture:

1. Scalability: The client-server architecture allows for horizontal scalability,

meaning that as the number of clients increases, more servers can be added to
handle the load. This enables applications to handle a large number of
concurrent users without sacrificing performance.
2. Reliability: By separating the client and server components, the client-server
architecture enhances reliability. If one server fails, the application can continue
to function by redirecting requests to other available servers. Additionally,
server-side components can be replicated for fault tolerance.
3. Security: The client-server architecture enables the implementation of security
measures at the server-side, protecting sensitive data and preventing
unauthorized access. This centralized approach to security allows for easier
management and enforcement of security policies.
4. Interoperability: The client-server architecture promotes interoperability
between different systems and platforms. Clients and servers can be developed
using different technologies, as long as they adhere to the communication
protocols and standards defined by the architecture.

Dr KITOUNI Ilham 2
Distributed Application Development and Middleware (DARM) 2023/2024 Semester 1

Advantages of client-server architecture

The client-server architecture offers several advantages for distributed application
development:

• Modularity: The separation of concerns between the client and server

components allows for modularity, making it easier to understand, maintain, and
update the different parts of the application independently.
• Flexibility: The client-server architecture provides flexibility in terms of
deployment options. Clients can be deployed on different devices, such as
desktop computers, laptops, or mobile devices, while servers can be deployed
on dedicated hardware or in the cloud.
• Efficiency: By offloading the processing and data storage tasks to the server,
clients can focus on providing a responsive user interface. This improves the
overall efficiency and performance of the application.
• Resource sharing: With the client-server architecture, multiple clients can
share the same server resources, such as databases or files. This promotes
resource optimization and reduces duplication of data.

Conclusion
The client-server architecture is a fundamental concept in distributed application
development. It provides a clear separation of concerns, scalability, reliability, security,
and interoperability. By leveraging the advantages of this architecture, developers can
create robust and efficient distributed applications that meet the needs of modern
computing environments.
In the previous section, we explored the client-server architecture, which is one of the
fundamental programming models for building distributed applications. In this section,
we will delve into another widely used programming model known as the message-
passing model.

Message-Passing Model
The message-passing model is a programming paradigm that enables communication
and coordination between different components of a distributed system through
message exchange. In this model, components are typically referred to as processes,
which can be running on different machines or nodes.
In the message-passing model, processes communicate by sending and receiving
messages. Messages can contain data or instructions and are exchanged through
communication channels, which can be implemented using various underlying
protocols such as TCP/IP or UDP.
There are two main communication paradigms within the message-passing model:
synchronous and asynchronous communication.

Synchronous Communication
In synchronous communication, the sender process blocks until the receiver process
acknowledges the receipt of the message. This blocking behavior ensures that the

Dr KITOUNI Ilham 3
Distributed Application Development and Middleware (DARM) 2023/2024 Semester 1

sender process waits for the response from the receiver before proceeding with its
execution. Synchronous communication is often used when a direct response or
immediate synchronization is required between processes.
One common example of synchronous communication is the request-reply pattern,
where a client process sends a request message to a server process and waits for the
server to respond with a reply message. This pattern is commonly used in client-server
systems, where the client needs to wait for a response from the server before
continuing its execution.

Asynchronous Communication
In asynchronous communication, the sender process does not block after sending a
message. Instead, it continues its execution immediately without waiting for a response
from the receiver. Asynchronous communication is typically used when there is no
immediate need for a response or when parallel execution is desired.
One common example of asynchronous communication is the publish-subscribe
pattern, where a publisher process sends messages to multiple subscriber processes
without waiting for individual acknowledgments. Subscribers can receive and process
messages at their own rate, enabling parallelism and scalability.
The message-passing model provides several advantages for distributed application
development:

• Decoupling: The message-passing model enables loose coupling between

processes, as they only need to know how to send and receive messages. This
allows for easier modification and replacement of components without affecting
the overall system.
• Concurrency: Asynchronous communication allows for parallel execution of
processes, enabling better utilization of resources and improved performance.
• Scalability: The message-passing model supports the distribution of processes
across multiple machines, allowing for the scaling of applications to handle
increased workloads.

However, there are also challenges associated with the message-passing model:

• Complexity: Developing distributed applications using the message-passing

model can be more complex compared to the client-server architecture, as it
requires handling message passing, synchronization, and potential failures.
• Message Ordering: Ensuring the correct order of messages can be
challenging in distributed systems, especially when messages are sent
concurrently from multiple processes.
• Error Handling: Dealing with errors, such as message loss or process failures,
requires careful consideration and implementation of error handling
mechanisms.

It is essential to carefully design and implement message-passing systems to address

these challenges and take advantage of the benefits offered by this programming
model.

Dr KITOUNI Ilham 4
Distributed Application Development and Middleware (DARM) 2023/2024 Semester 1

Now that we have explored the message-passing model, we have gained a deeper
understanding of the different programming models for distributed applications. In the
next section, we will discuss another important programming model: the remote
procedure call (RPC) model.

Remote Procedure Call (RPC)

Remote Procedure Call (RPC) is a programming model that allows a client program to
execute procedures or functions on a remote server as if they were local procedures.
It enables communication between different processes or machines over a network,
making it easier to develop distributed applications.
In RPC, the client program invokes a procedure on the remote server by sending a
request message. The server receives the request, executes the procedure, and sends
back the result to the client. From the client's perspective, the remote procedure
appears to be a local function call, abstracting away the complexities of network
communication.
RPC provides a transparent and simple way to build distributed applications. It allows
developers to focus on the logic of their application rather than the details of network
communication. The key components of RPC are:

1. Client: The program that initiates the RPC and invokes remote procedures.
2. Server: The program that receives the RPC requests, executes the requested
procedures, and sends back the results.
3. Interface Definition Language (IDL): A language or specification used to
define the interfaces and data structures of the remote procedures. IDL provides
a way to describe the methods, parameters, and return types of the remote
procedures.
4. Stub: On the client side, a stub is generated based on the IDL specification.
The stub acts as a proxy for the remote procedure, marshaling the parameters,
making the network call, and unmarshaling the results.
5. Skeleton: On the server side, a skeleton is generated based on the IDL
specification. The skeleton receives the RPC request, unmarshals the
parameters, executes the procedure, and marshals the results.
6. Marshaling and unmarshaling: The process of converting the parameters and
results of the remote procedure into a format that can be transmitted over the
network. Marshaling is performed by the stub on the client side, and
unmarshaling is performed by the skeleton on the server side.

RPC provides several benefits for distributed application development:

• Abstraction: RPC hides the complexities of network communication, allowing

developers to focus on the application logic. It provides a simple and familiar
programming model, similar to local function calls.
• Code Reusability: RPC enables code reusability by allowing remote
procedures to be invoked from multiple clients. Developers can separate the
implementation of procedures from their invocation, making it easier to maintain
and update distributed applications.

Dr KITOUNI Ilham 5
Distributed Application Development and Middleware (DARM) 2023/2024 Semester 1

• Interoperability: RPC supports interoperability between different programming

languages and platforms. As long as the client and server agree on the IDL
specification, they can communicate and exchange data seamlessly.
• Performance: RPC can be optimized for performance by implementing
techniques such as caching, connection pooling, and parallel execution.
Efficient network protocols, like TCP/IP or UDP, can be used to minimize latency
and maximize throughput.
• Scalability: RPC allows applications to scale by distributing the workload
across multiple servers. As the number of clients and requests increases,
additional servers can be added to handle the load, providing better
performance and availability.

However, RPC also has some limitations and considerations that developers should
be aware of:

• Network Dependency: RPC relies on network communication, which

introduces potential issues such as latency, network failures, and security
vulnerabilities. Developers need to handle error scenarios and implement
appropriate mechanisms for fault tolerance and security.
• Versioning: Changes to the interface or behavior of remote procedures may
break compatibility between the client and server. Developers need to carefully
manage versioning to ensure backward compatibility and smooth upgrades.
• Performance Overhead: Marshaling and unmarshaling of parameters and
results can introduce performance overhead, especially for large data transfers.
Developers should consider optimizing data serialization and choose efficient
network protocols.

In conclusion, RPC is a powerful programming model for developing distributed

applications. It provides a transparent and simple way to invoke remote procedures,
abstracting away the complexities of network communication.

Distributed Objects
In the previous sections, we explored various programming models for distributed
applications, such as the client-server architecture, message-passing model, and
remote procedure call (RPC). Now, let's delve into the concept of distributed objects,
which is another powerful programming model used in distributed systems.

Definition of Distributed Objects

Distributed objects are objects that are distributed across multiple computer systems
in a network. They encapsulate both data and behavior, allowing clients to interact with
them as if they were local objects. This abstraction simplifies the development of
distributed applications by providing a seamless way to access remote resources.

Key Features of Distributed Objects

When working with distributed objects, there are several key features to consider:

Dr KITOUNI Ilham 6
Distributed Application Development and Middleware (DARM) 2023/2024 Semester 1

1. Location Transparency: Distributed objects abstract away the details of their

physical location. Clients can interact with them without needing to know the
specific network addresses or locations of the objects. This allows for easier
scalability and flexibility in distributed systems.
2. Interoperability: Distributed objects can be developed using different
programming languages and technologies. They can communicate and interact
with each other regardless of the underlying implementation details. This
promotes system integration and reusability.
3. Concurrency: Distributed objects can be accessed by multiple clients
concurrently. To ensure data consistency and avoid conflicts, mechanisms such
as locking and synchronization are employed. Proper concurrency control is
crucial for maintaining the integrity of the distributed system.
4. Persistence: Distributed objects can be made persistent, meaning their state
is stored and maintained even when the object is not actively being used. This
enables fault tolerance and recovery in case of system failures.
5. Security: Distributed objects often require secure communication channels and
access control mechanisms to protect sensitive data and prevent unauthorized
access. Encryption, authentication, and authorization techniques are commonly
used to ensure the security of distributed systems.

Benefits of Distributed Objects

The use of distributed objects in distributed application development offers several
benefits:

• Modularity and Reusability: Distributed objects promote modular design and

encapsulation, allowing developers to create reusable components. These
components can be easily shared and accessed by multiple applications,
improving productivity and reducing development time.
• Scalability: Distributed objects facilitate the scalability of distributed systems.
As the number of clients and resources increases, additional instances of
distributed objects can be deployed across the network to handle the increased
load. This allows for efficient resource utilization and improved system
performance.
• Maintenance and Flexibility: Distributed objects enable the modification and
upgrading of individual components without affecting the entire system. This
flexibility simplifies maintenance tasks and allows for system evolution over
time.
• Fault Tolerance: By replicating distributed objects across multiple nodes, fault
tolerance can be achieved. If one node fails, other replicas can continue to
provide the required functionality, ensuring system availability.

Implementing Distributed Objects

There are various middleware technologies and frameworks available to implement
distributed objects, such as CORBA (Common Object Request Broker Architecture),
Java RMI (Remote Method Invocation), and .NET Remoting. These technologies
provide the necessary infrastructure and protocols to enable transparent
communication and interaction between distributed objects.

When developing distributed objects, it is essential to consider factors such as

performance, reliability, and maintainability. Proper design patterns, architectural

Dr KITOUNI Ilham 7
Distributed Application Development and Middleware (DARM) 2023/2024 Semester 1

principles, and best practices should be followed to ensure the success of distributed
application development.

Conclusion
Distributed objects offer a powerful programming model for developing distributed
applications. They provide location transparency, interoperability, concurrency control,
persistence, and security. By utilizing distributed objects, developers can achieve
modularity, scalability, maintenance flexibility, and fault tolerance in their distributed
systems.

Agent-based programming
Agent-based programming is a programming paradigm that focuses on the design and
implementation of autonomous software entities known as agents within a distributed
system. These agents are capable of acting independently and making decisions
based on their local knowledge and interactions with other agents.

Unlike traditional programming models, where the system is divided into clients and
servers, agent-based programming introduces a more decentralized approach. Agents
are considered to be active entities that can communicate and collaborate with other
agents to achieve a common goal.

One of the key advantages of agent-based programming is its ability to handle complex
and dynamic environments. Agents can adapt and react to changes in the system,
making it suitable for applications that require flexibility and responsiveness. This
programming model is particularly useful in areas such as multi-agent systems,
intelligent systems, and distributed artificial intelligence.

In agent-based programming, agents are designed to possess certain characteristics:

1. Autonomy: Agents have the ability to act independently and make decisions
based on their own internal state and knowledge.
2. Proactivity: Agents are proactive and can initiate actions without external
stimuli.
3. Reactivity: Agents can react to changes in the environment or other agents'
actions.
4. Social ability: Agents can communicate and interact with other agents to
exchange information and collaborate.

Agent-based programming provides several benefits over traditional programming

models:

• Flexibility: Agents can dynamically adapt to changing requirements and

environments, making the system more flexible and resilient.
• Scalability: Agent-based systems can scale well as the number of agents
increases, as agents can distribute the workload and collaborate efficiently.
• Fault-tolerance: Agents can continue to operate even if some agents fail,
ensuring the system's robustness and fault-tolerance.
• Intelligence: Agents can be programmed to exhibit intelligent behavior,
enabling them to solve complex problems and make decisions.

Dr KITOUNI Ilham 8
Distributed Application Development and Middleware (DARM) 2023/2024 Semester 1

Agent-based programming can be implemented using various technologies and

frameworks. One popular framework is the Java Agent Development Framework
(JADE), which provides a set of tools and libraries for developing agent-based
applications in Java.

When designing an agent-based system, careful consideration should be given to the

communication and coordination mechanisms between agents. This includes choosing
appropriate message-passing protocols, defining agent architectures, and designing
negotiation and cooperation strategies.

Overall, agent-based programming offers a powerful approach to developing

distributed applications. By leveraging the autonomy and intelligence of agents,
complex systems can be designed and implemented in a decentralized and adaptable
manner.

Comparison of Message Passing,

Distributed Objects, and Agent-Based
Programming
Message passing, distributed objects, and agent-based programming are three
programming models commonly used in the development of distributed applications.
Each model offers unique features and advantages, making them suitable for different
scenarios. In this section, we will compare these three models to help you understand
their differences and choose the most appropriate one.

Message Passing
Message passing is a communication model where processes or objects communicate
by sending and receiving messages. In this model, the sender explicitly specifies the
recipient of the message. The message contains information or instructions that the
recipient can process.

Message passing provides a simple and flexible way to exchange data between
distributed components. It allows for direct communication between components,
enabling efficient and fine-grained control over the communication process. However,
it requires explicit handling of message routing, synchronization, and error handling.

Distributed Objects
Distributed objects model treats remote objects as local objects, abstracting the
complexities of distributed communication. In this model, objects from different
locations can interact with each other as if they were located in the same address
space.

Distributed objects offer a high level of abstraction, promoting code reusability and
modular design. They encapsulate both data and behavior, allowing for seamless
integration of remote components. However, this model introduces additional overhead
for object serialization, remote method invocation, and object lifecycle management.

Dr KITOUNI Ilham 9
Distributed Application Development and Middleware (DARM) 2023/2024 Semester 1

Agent-Based Programming
Agent-based programming model focuses on autonomous and intelligent entities
called agents. These agents have their own goals, knowledge, and decision-making
capabilities. They can interact with each other and the environment to achieve their
objectives.

Agent-based programming offers a decentralized and flexible approach to distributed

application development. It promotes modularity, scalability, and adaptability. Agents
can collaborate, negotiate, and coordinate their activities to solve complex problems.
However, this model requires sophisticated agent coordination mechanisms and may
introduce additional complexity in system design and implementation.

Feature Message Passing Distributed Agent-Based

Objects Programming

Communication Explicit message Transparent Autonomous agent

sending and receiving remote object communication and
interaction coordination

Abstraction Low-level, fine- High-level, Very high-level,

grained control seamless decentralized
integration approach

Code Reusability Limited Good Excellent

Scalability Good for moderate Good for Excellent for large-

number of moderate scale systems
components number of
components
Complexity Relatively More complex Most complex of the
straightforward than message three models
passing
Application Domain Good for applications Good for Good for multi-agent
requiring fine-grained enterprise systems and
control over applications applications with
communication and distributed autonomous entities
systems

Choosing the Right Model

When choosing a programming model for distributed application, the following factors
have to be considered:

• Communication Requirements: If application requires fine-grained control over the

communication process, message passing may be the most suitable choice. If a high-
level abstraction and seamless integration of remote components, distributed objects
may be a better option. If application involves autonomous entities and complex
interactions, agent-based programming might be the right fit.

Dr KITOUNI Ilham 10
Distributed Application Development and Middleware (DARM) 2023/2024 Semester 1

• Scalability: Consider the scalability requirements of the application. Message passing

and distributed objects can scale well for a moderate number of components. However,
agent-based programming excels in handling large-scale systems with numerous
autonomous agents.
• Complexity: The complexity of the application and the development team's expertise
have to be evaluated. Message passing is relatively straightforward to implement and
understand. Distributed objects require additional considerations for serialization,
remote method invocation, and lifecycle management. Agent-based programming
introduces a higher level of complexity with agent coordination and negotiation
mechanisms.
• Application Domain: Finally, the specific requirements and characteristics of the
application domain have to be considered. Some domains may naturally lend
themselves to a particular programming model. For example, agent-based
programming is commonly used in multi-agent systems, while distributed objects are
prevalent in enterprise applications.

Case Studies of Distributed Systems that

Use Different Programming Models
In this section, we will explore several case studies of real-world distributed systems
that utilize different programming models. These case studies will provide practical
examples of how different programming models can be applied to solve specific
problems in distributed application development.

Case Study 1: Client-Server Architecture

One popular case study of a distributed system that adopts the client-server
architecture is the World Wide Web. In this model, web browsers act as clients, sending
HTTP requests to web servers, which then respond with HTML pages or other
resources. This architecture allows for the efficient dissemination of information and
enables users to access web pages from anywhere in the world.

Another example is the email system, where clients (such as Outlook or Gmail)
communicate with mail servers to send and receive emails. The client-server
architecture provides a reliable and scalable solution for handling the vast amount of
email traffic worldwide.

Case Study 2: Message-Passing Model

The Message Passing Interface (MPI) is a widely used programming model for
distributed memory systems. It enables high-performance computing by allowing
multiple processes to communicate with each other through message passing. One
example of a distributed system that utilizes the message-passing model is the
SETI@home project, which uses volunteers' idle computer resources to analyze radio
signals from space in search of extraterrestrial intelligence.

Another case study is the Apache Kafka messaging system, which is designed for
handling high-throughput, fault-tolerant, and scalable data streaming applications.
Kafka utilizes a publish-subscribe model where producers send messages to topics,
and consumers subscribe to those topics to receive the messages. This message-
passing model enables real-time data processing and analysis in distributed systems.

Dr KITOUNI Ilham 11
Distributed Application Development and Middleware (DARM) 2023/2024 Semester 1

Case Study 3: Remote Procedure Call (RPC)

A well-known example of a distributed system that employs the remote procedure call
model is the Sun RPC framework, which is used for developing client-server
applications. Sun RPC allows clients to invoke procedures on remote servers as if they
were local. This model simplifies the development of distributed applications by
abstracting the communication details between the client and server.

Another case study is the Google Protocol Buffers (protobuf) framework, which
provides a language-agnostic mechanism for serializing structured data. Protobuf
supports RPC communication between distributed systems, allowing clients to invoke
methods on remote servers using a defined protocol. This model enables efficient data
exchange and interoperability between different programming languages.

Case Study 4: Distributed Objects

The Java Remote Method Invocation (RMI) framework is an example of a distributed
system that utilizes distributed objects. RMI allows objects in a Java Virtual Machine
(JVM) to invoke methods on remote objects located in other JVMs. This model
simplifies the development of distributed applications by abstracting the network
communication and object serialization.

Another case study is the Common Object Request Broker Architecture (CORBA),
which is a middleware standard for developing distributed systems. CORBA enables
objects written in different programming languages to communicate with each other
seamlessly. This distributed object model provides a high level of interoperability and
flexibility in distributed application development.

Case Study 5: Agent-Based Programming

The RoboCup project is an example of a distributed system that adopts agent-based
programming. RoboCup is an international initiative where teams of autonomous
robots play soccer against each other. Each robot acts as an agent, making decisions
and coordinating with other agents to achieve team objectives. This agent-based
programming model allows for complex coordination and collaboration in distributed
systems.

Another case study is the JADE (Java Agent Development Framework), which is a
platform for developing agent-based applications. JADE provides a set of tools and
libraries for creating intelligent agents that can interact with each other using message
passing. This model enables the development of distributed systems with advanced
capabilities, such as intelligent decision-making and adaptive behavior.

References:

• George Coulouris, Jean Dollimore, Tim Kindberg, Gordon Blair. Distributed

Systems: Concepts and Design. 5th

Dr KITOUNI Ilham 12