FEDERAL TVET INSTITUTE

Department of Information and

Communication Technology

COURSE TITLE: - DISTRIBUTED SYSTEM

Assignment for distributed system 2019

Name: Yosef Jote / Id: MTR/108/10 / MSC / TVETI

Submitted to:[Link]

10/01/2019
Q1. How distributed computing systems are going to be evolved in future and explain it
briefly mentioning/citing with proper references.
With the extensive deployment of distributed systems, the management and integration of these
systems have become challenging problems, especially after smart procedures are implemented.
Researchers build new technologies to deal with these problems. Trends of the future Web require
inserting intelligence into the distributed computing model; thus, the goal of future research is
intelligent distributed computing. At this time, the research introduces the cell computing theory to
cover the distributed system problems through intelligent method of processing. Cell theory is the
implementation of human cells’ functions in a distributed computational environment. The cell is an
intelligent, organized, secure and dynamic component that serves a specific type of job. Cell
methodology divides the task between two types of components, the commander and the executer.
The commander is a light cell that represents the client and can communicate smartly with its
distributed environment to request solutions. The executive cell works as a smart supplier that
depends on wide collaborations to fabricate a solution. Cell strategy is based on high-level
communication among Cells, a permanent analysing process among collaborating components and
context-based security among collaborating

Distributed Computing - Field to study distributed system

Distributed System - hardware or software components located at networked computers communicate and
coordinate their actions only by message passing.

❖ Motivation of distributed computing:

➢ Demand for high computation power - solve complex problems
➢ Desire of resource sharing - increase efficiency
➢ Rapid growing of network infrastructure - immediate feedback
❖ Trends of distributed computing systems are:
A) Grid Computing
✓ Allow variety of geographically distributed resources to be shared and aggregate
✓ Grid Broker:-
– Negotiate for access costs
– Schedule, deploy tasks and collect final results
✓ Benefits:- Transparent, On-demand access, Improved productivity, and Extra resources
to solve problem
Example:
Financial Organization - Collaboration for computational power
 Online Multiplayer Game - Dedicated game server in various country
Weather Forecasting - Require high data and computational power
B) Mobile & Ubiquitous Computing
✓ Mobile computing enable:-
– Use of a computing device even though they are moving around
– Can continue access the resources in their home such as printer and etc
✓ Known as location-aware/context-aware computing
✓ Ubiquitous computing: -
– new genre of DC that permeates user's life
– Enable devices and computers become helpful but invisible force to fulfilled user
needs
– Example: remotely control appliances in home through user smart phone. The
appliances will notify the user when job done
C) Cloud Computing
✓ A model for enabling convenient, on-demand network access to a shared pool of
configurable computing resources that can rapidly portioned and released with minimal
management effort or service provider interaction
✓ Clustering a set of computers to provide the scale and performance for cloud
✓ Benefits:-
– Flexible and storage of resources
– Allow wide range of resource sharing

A) Future Investigation
✓ Security and Privacy Issue for DC
– Main concern
– All nodes are interconnected, easy to penetrate
– Implicit trust must be built
– Proper guidelines needed
B) Future Trend of Distributed Computing
✓ Continuum Computing
– Enable resource sharing and remote control easily
– Example 1: Transferring recipe from personal computer to tablet
– Example 2: Smart devices provide info about what is happening on other channels
before user change the channel of TV
– Need all appliances to connected to the cloud
 ✓ Smartphone Grids / Smart Grids
– Interconnected smart phone or smart devices into a grid like Grid Computing
– Provide slightly amount of computational power
– Solve complex problems on smart devices
Q2: Write limitations of following technologies [Link] b. SOA c. SOAP d. spring.
❖ Simple Object Access Protocol(SOAP) is a messaging protocol that allows programs that run on
disparate operating systems (such as Windows and Linux) to communicate using Hypertext Transfer
Protocol (HTTP) and its Extensible Markup Language (XML).
Limitations of SOAP is

• SOAP is typically much slower than other types of middleware standards, including
CORBA. This due to the fact that SOAP uses a verbose XML format. You need to fully
understand the performance limitations before building applications around SOAP.
• SOAP is typically limited to pooling, and not event notifications, when leveraging HTTP
for transport. What's more, only one client can use the services of one server in typical
situations.
• No good way to describe the serialization pattern (XML schema is optional at this point)
• Parsing of SOAP packet and mapping to objects reduces performance
• Doesn’t implement security because it is a wire protocol—relies on HTTP

❖ Service Oriented Architecture (SOA) is an emerging architectural style for developing and
integrating enterprise applications. It is an organizational and technical framework to enable an
enterprise to deliver self-describing and platform independent business functionality providing a
way of sharing business functions and services in a widespread and flexible way

Limitations of SOA
is a much better architecture as opposed to distributed client server architecture and it can
bring huge benefits in the form of code reuse, better integration and improved responsiveness
to business needs. However, the eternal battle between flexibility and efficiency exists in just
the same way as it always has. Obviously, it is desirable to develop architectures that allow
easy integration of the existing and new enterprise applications. However, the integration
technology solutions are often proprietary which present issues of inoperability. Mention the
following problems with respect to the existing distributed architectures: •
 ➢ Vendor lock-ins: as much architecture is based on proprietary protocols and implementations.
➢ Tight coupling: as distributed architectures typically link components directly to one another.
➢ Complexity: as the interactions between objects are often rich and complex.
➢ Connectivity: as majority of distributed architectures do not work over wide-area, intermittent
networks.
➢ SOA also requires a large upfront investment by way of technology, development and staff
deployment. It may cost a great deal and the Return on Investment (ROI) could take a long
time to materialize.
✓ Not a universal remedy for today’s mix and match architectures
✓ It is not a solution for all upcoming challenges
✓ Not best practice for long-running asynchronous processes
✓ Natural strengths in real-time request-response exchanges (asynchronous and
synchronous)
✓ SOA requires an environmental framework
➢ .NET, SAP Net Weaver, IBM Web Sphere, BEA Web Logic
➢ Platform independence not yet achieved

❖ Most critical issues are pending security issues

➢ Physical Network
✓ Need Intra- and Inter-organizational security
➢ SOAP Messages
✓ Need to protect content of SOAP Messages
➢ Endpoint (Web Service) Security
✓ Need Intra- and Inter-organizational security
➢ Extensive security framework worked out
➢ Applicable products on the market
➢ For mission critical processes, security measures still an issue
❖ Not valuable for applications whose business logic components are in a closed
application domain
❖ Extensible Markup Language (XML) is a standard set of rules for writing documents in a
way that a computer can read them. It doesn't say anything about what the documents mean, or how
they will be used. Because tools to write and read XML exist in every programming language, it has
become a popular way to transmit data between computer programs, especially across networks.
A programmer or information worker can create an "XML language" that describes any kind of data
that they need; for example, a word processing document
There are also limitations to the XML that must be considered, such as:
➢ The lack of powerful applications that can process XML data and actually make the data
useful is a primary limitation of the language. Only in recent history have browsers began to
have the ability to read XML. Even now, these browsers still make use of HTML to render
the XML document. This means that as of now, XML cannot be used as a language that is
independent of HTML.
➢ Other limitations of XML results from the unlimited flexibility of the language. The tags
implemented in a document are solely chosen by the creator. There is not a standard or
generally accepted set of tags to be used in an XML document. As a result of this, designers
can not just create general applications because each company will invariably have their own
set of special tags and unique meaning for those tags

❖ SPRING The term "spring" means different things in different contexts. It can be used to refer to
the Spring Framework project itself, which is where it all started. Over time, other spring projects
have been built on top of the Spring Framework. Most often, when people say "spring", they
mean the entire family of projects.

➢ The leading limitations of spring are it size; it tries to be all in one Java Development
framework. It works fine when you do have architectural standards followed in your company
for the usage of any frameworks.
➢ Some of the main limitations of spring are:

1. Learning Curve: Some developers find it hard to understand the concept of IOC and
Dependency Injection. Due to this they do not realize full potential of spring.
2. Changing Nature: Spring keeps changing over the time. As of now the annotation based
spring configuration is not an easy thing for everybody to use. This causes a big blocker for
some people to use spring.
3. Dependency Injection: This is a paradox. Spring promotes Dependency Injection (DI).
But if you start using spring, your project becomes dependent on spring framework. This is
a dependency that you are creating for your project. You may not be able to come out of it
in future.
Q3. Explain working principles of 2 phase locking and 3 phase locking
Working principle of two phase locking: is a process used to gain ownership of shared resources
without creating the possibility for deadlock. The technique is extremely simple, and breaks up the
modification of shared data into "two phases", this is what gives the process its name.

There are actually three activities that take place in the "two phase" update algorithm:

1. Lock Acquisition
2. Modification of Data
3. Release Locks
The modification of data and the subsequent release of the locks that protected the data are generally
grouped together and called the second phase. Two phase locking prevents deadlock from occurring
in distributed systems by releasing all the resources it has acquired, if it is not possible to obtain all
the resources required without waiting for another process to finish using a lock. This means that no
process is ever in a state where it is holding some shared resources, and waiting for another process to
release a shared resource which it requires. This means that deadlock cannot occur due to resource
contention.
The resource (or lock) acquisition phase of a "two phase" shared data access protocol is usually
implemented as a loop within which all the locks required to access the shared data are acquired one
by one. If any lock is not acquired on the first attempt the algorithm gives up all the locks it had
previously been able to get and starts to try to get all the locks again.
According to this rule of protocol , every transaction can be divided into two phases:

First: growing phase, in which it acquires all the locks needed but cannot release any new locks.
There is no requirement that all locks to obtained simultaneously .Normally , the transaction acquires
some locks, doe some processing and goes on to acquire additional locks as needed. However, it
never releases any lock until it has reached a stage where no new locks are needed. The rules are:

• A transaction must acquire a lock on an item before operating on the item. The lock may be read
or write, depending on the type of access needed.
• Once the transaction releases a lock, it can never acquire any new locks.
Property of 2PL :

• Generates conflict-serializable schedules

• But schedules may cause cascading aborts

If a transaction aborts after it releases a lock, it may cause other transactions that

have accessed the unlocked data item to abort as well

Strickt two phase locking

✓ It holds locks untill the end

✓ Cascading aborts are avoided

Working principle of three phase locking:
➢ Not a necessity used a lot.
➢ Procedures available to solve 2PL’s problems.
➢ Dependent on the nature of the data and the environment: changing data, many users.
➢ Types of locks used: Read, Write, Write Intent
➢ User signs in and requests data from the database.
➢ Read lock is applied to the data.
➢ Once the data is read, the Read lock is dropped.
➢ There can be multiple Read locks by multiple users on the same data/tuple.
 ➢ All locks are subject to timeouts, with appropriate actions (unlocks, error/warning messages to
user etc) taken in the event of lock failure. This prevents deadlocks.
➢ Same locking protocol is used to access the data in question.
➢ No other protocol should be applied or considered as it may disrupt the flow of operations.
➢ UPDATE: Only WRITE-INTENT locks can be held for any length of time, typically because the
record of interest is at the mercy of the user in edit mode...
➢ This is actually not dissimilar to the way many "modern" relational databases handle locking,
➢ The average RDBMS can't support the degree of control involved here and 3PL developed out of
need.
Q4. Describe the essentiality of transaction management and explain how transaction
management works in distributed platforms.
Transaction Management deals with the problems of keeping the database in a consistent state even
when concurrent accesses and failures occur, (Ozsu et al., 1991).
A transaction consists of a series of operations performed on a database. The important issue in
transaction management is that if a database was in a consistent state prior to the initiation of a
transaction, then the database should return to a consistent state after the transaction is completed.
This should be done irrespective of the fact that transactions were successfully executed
simultaneously or there were failures during the execution, (Ozsu et al., 1991). Thus, a transaction is
a unit of consistency and reliability. The properties of transactions will be discussed later in the
properties section.
Each transaction has to terminate. The outcome of the termination depends on the success or failure
of the transaction.
When a transaction starts executing, it may terminate with one of two possibilities:
1. The transaction aborts if a failure occurred during its execution
2. The transaction commits if it was completed successfully.

Figure 1a shows an example of a

transaction that aborts during process 2
(P2). On the other hand, Figure 1b shows
an example of a transaction that commits,
since all of its processes are successfully
completed.

Figure1: Aborted and Committed

Properties of Transactions
A Transaction has four properties that lead to the consistency and reliability of a distributed data base.
These are Atomicity, Consistency, Isolation, and Durability, (Ozsu et al., 1991).
❖ Atomicity.
➢ This refers to the fact that a transaction is treated as a unit of operation. Consequently, it
dictates that either all the actions related to a transaction are completed or none of them is
carried out. For example, in the case of a crash, the system should complete the remainder
of the transaction, or it will undo all the actions pertaining to this transaction.
❖ Consistency.
➢ Referring to its correctness, this property deals with maintaining consistent data in a
database system. Consistency falls under the subject of concurrency control. For example,
“dirty data” is data that has been modified by a transaction that has not yet committed. Thus,
the job of concurrency control is to be able to disallow transactions from reading or
updating “dirty data.”
❖ Isolation.
➢ According to this property, each transaction should see a consistent database at all times.
Consequently, no other transaction can read or modify data that is being modified by
another transaction. If this property is not maintained, one of two things could happen to the
data base, as shown in Figure 2:
✓ Lost Updates: this occurs when another transaction (T2) updates the same data being
modified by the first transaction (T1) in such a manner that T2 reads the value prior to
the writing of T1 thus creating the problem of loosing this update.
✓ Cascading Aborts: this problem occurs when the first transaction (T1) aborts, then the
transactions that had read or modified data that has been used by T1 will also abort.

Figure 2: Isolation
❖ Durability.
➢ This property ensures that once a transaction commits, its results are permanent and cannot
be erased from the database. This means that whatever happens after the COMMIT of a
transaction, whether it is a system crash or aborts of other transactions, the results already
committed are not modified or undone.
Q5: What are different simulation/emulation frameworks available for distributed computing
platforms to simulate and compare and contrast its capabilities.

Simulation has become the evaluation method of choice for many areas of distributing computing
research. However, most existing simulation packages have several limitations on the size and
complexity of the system being modeled. Fine grained simulation of complex systems such as Grids
requires high computational effort which can only be obtained by using an underlying distributed
architecture. We are proposing a new distributed simulation system that has the advantage of being
able to model very complex distributed systems while hiding the computational effort from the end-
user.
Simulation:
To simulate is to reproduce the behaviour of a physical system with a model practically, computers
are used to numerically simulate a logical model.
Simulations are used for performance evaluation and prediction of complex systems
Simulation is more flexible than analytical methods

The differences between simulation and emulation?

Simulation is when you are replicating, by the means of software, the general behavior of a system
starting from a conceptual model. Whereas Emulation is when you are replicating, in a different
system, how the original system actually internally works considering each function and their
relations.
In other words: Simulation is based on a software implementation of a model where the internal
functions of the original systems are not taken into consideration (for example a "flight simulator"
does not have any "component" of an actual aircraft).
Emulation is a replica of the internal system functions on a different host (for example on a Mac OS
X I can write a software emulator of a Windows OS where a Win program can run). Emulators can
also be strictly hardware-based and are normally based on a partial or complete "reverse engineering"
phase.
The Simulator tries to duplicate the behavior of the device.
The Emulator tries to duplicate the inner workings of the device
Emulator is a piece of software that tries to copy the behavior of the another software. Internally both
softwares’ may work in different ways and have different states. The basic use of emulator is to
replace the original software it is trying to emulate. VMware player is a emulator which emulates a
hardware on which you can run different OS.
Simulator is a piece of software that performs operations of the other software. Here both software’s
will have the same internal states. Simulator actually recreates the behavior of the target software.
Flight simulator is software that simulates the real look and feel of an aircraft flying.

Simulation principle:
Execution of a discrete event simulation on a parallel or distributed system with several physical
processors.

The simulation model is decomposed into several sub-models that can be executed in parallel

✓ special partitioning,
✓ Temporal partitioning, radically different from simple simulation replications.

Q6: Write different approach to achieve high performance in distributed environments.

High performance can be achieved by using different computer environment. High performance
computing is defined as the development and use of the fastest and most powerful computer system ,
so different approach has been developed to achieve high performance in distributed system . the
following are discussed as follow

1. Cluster computing
IMB sighted cluster computing as a substitute to coupling thumping mainframes, to provide a
more profitable form of economic affinity. in 1960s IBM‟s Houston Automatic Spooling
Priority
(HASP) system and its heritor, Job Entry System (JES), permitted dissemination of effort to a
nodemanufactured mainframe cluster. IBM still opts clustering of mainframes via parallel
systems, permitting hardware, operating systems, middleware and system management
software to maintain powerful conduct and cost improvements allowingmassive mainframe
users to pursue executing their current operation.
The high- availability and load- balancing capability of clusters attracts customers and
interestsinvestors. Due to low cost and elasticity they areeasier to handle and maintain.
Ubiquitous approachmaximizes its efficiency and performance. Asclusters are simple in
design, every node can begranted required attention, thus, avoiding affects ofnode failures.
The Linux world supports various cluster software. Linux Virtual Server, Linux-HA-
directorbased clusters permit entry for services to be distributed among several cluster nodes.
 OpenMosix, Kerrighed, OpenSSI are clusters consolidated into kernel that provide for direct
process transfers among homogeneous nodes. Microsoft Windows Computer Cluster Server
2003 dependent on Window server platform, permits parts for High Performance Computing
like, Job Scheduler and management tools.

2. Grid Computing
Grid computing is an essence of distributed computing. Just as internet user sees a
consolidated instance of content through web, a grid user views a single, large virtual
computer. Grid technologies commit to change the way in which complex computational
problems are tackled by organizations. However, the intent of large-scale resource sharing has
not yet been accomplished in several areas. Grid computing has developed the field of
computing. Started as a project to link US supercomputers, Grid computing has evolved far
beyond.
Grid computing is based on an open set of standards and protocols which enable
communication across geographically dispersed and heterogeneous environment. Example of
grid architecture is Open Grid Services Architecture (OGSA). Like all other computing, grid
architecture is also defined in layers. There are four layers in grid architecture, lowest being
the network layer which connects the grid resources and highest being the application layer
which includes applications in science, engineering, business, finances and more as well as
portal and development toolkits to support the applications. This is the layer that a grid user
can view and interact with. The application layer often includes the service-ware which
performs the general management functions like tracking, who is provided with grid resources
and who is using them. The intermediate layer known as middleware layer provides the tools
that enable various elements to participate in grid. The middleware layer is sometimes the
“brain” behind a computing grid . Resource layer is sandwiched between the network and
middleware layer. This layer contains the actual grid resources that are connected to the
network.

Grid system governs resources that are not subjected to centralized control by integrating
resources and users in different control domains. Built from multipurpose protocols and
interfaces that address issues like authentication, authorization, resource discovery and
resource access, grid uses standard, open, general-purpose protocols and interfaces. Grid
permits its constituent resources to be used in a managed way to deliver various nontrivial
qualities of service.
3. Cloud computing
Cloud computing which provides shared resources, software and information to computers
and other devices on demand is coined as “Internet Based computing”. Technical definition is
„a computing capability that provides an abstraction between the computing resource and its
underlying technical architecture (servers, storage, network), enabling convenient on demand
network access to a shared pool of configurable computing resources that can be rapidly
provisioned and released with minimal management effort or service provider interaction‟.
Cloud technologies have created a new trend in parallel programming . In this section, we
shall discuss more about the cloud computing.
The wide spectrum of services exposed by cloud are classified and organized into three main
offerings that are available to nodes: scientific, institution and enterprises via software,
platform and infrastructure as a service. Infrastructure as a service (IaaS) or hardware as a
service delivers IT infrastructure based on virtual or physical resources as a commodity to
customers. These resources meet the node requirements in terms of memory, CPU type and
power storage. Platform as a service (PaaS) provides a development platform where users can
develop their own applications and execute them on cloud. Google App Engine is an example
of such a service. Software as a service (SaaS) enables end user integrated services
comprising hardware development and applications. Users are not permitted to customize
these services but can access those services hosted in the cloud. An example of SaaS is a
Google Document

Q7: Explain major distributed platform areas and its algorithm strengths and weakness

Some of the notations and concepts from these areas will be employed from time to time in the
presentations for this course: „

1. Software engineering „

In building network applications, there are two main classes of programming languages: procedural
language and object-oriented language. „

➢ Procedural languages, with the C language being the primary example, use procedures
(functions) to break down the complexity of the tasks that an application entails. „
➢ Object-oriented languages, exemplified by Java, use objects to encapsulate the details. Each
object simulates an object in real life, carrying state data as well as behaviors. State data are
represented as instance data. Behaviors are represented as methods.
 2. Networks

Network standards and protocols

➢ „ On public networks such as the Internet, it is necessary for a common set of rules to be
specified for the exchange of data. „ Such rules, called protocols, specify such matters as the
formatting and semantics of data, flow control, error correction.
➢ „ Software can share data over the network using network software which supports a common
set of protocols.„
3. Operating systems
➢ A process consists of an executing program, its current values, state information, and the
resources used by the operating system to manage its execution. „
➢ A program is an artifact constructed by a software developer; a process is a dynamic entity
which exists only when a program is run

❖ Distributed computing systems: Goal: High performance computing tasks.

➢ Cluster Computing Systems:
✓ A “supercomputer” built from “off the shelf” computer in a high-speed network
(usually a LAN)
✓ Most common use: a single program is run in parallel on multiple machines
➢ Grid Computing Systems:
✓ Contrary to clusters, grids are usually composed of different types of computers
(hardware, OS, network, security, etc.)
✓ Resources from different organizations are brought together to allow
❖ Distributed information systems: Goal: Distribute information across several Servers.
➢ Remote processes called Clients access the servers to manipulate the information
➢ Different communication models are used. The most usual are RPC (Remote Procedure
Calls) and the object oriented RMI (Remote Method Invocations)
➢ Often associated with Transaction systems
➢ Examples: Banks; Travel agencies; Rent-a-Cars’; Etc…
❖ Distributed pervasive systems: − These are the distributed systems involving mobile and
embedded computer devices like Small, wireless, battery-powered devices (PDA’s, smart phones,
sensors, wireless surveillance cams, portable ECG monitors, etc.)
 ➢ These systems characterized by their “instability” when compared to more “traditional”
distributed systems
➢ Pervasive Systems are all around us, and ideally should be able to adapt to the lack of
human administrative control:
✓ Automatically connect to a different network;
✓ Discover services and react accordingly;
✓ Automatic self configuration (E.g.: UPnP – Universal Plug and Play)…
✓ Examples: Home Systems, Electronic Health Care Systems, Sensor Networks, etc.
Strengthens of Distributed platform:
❖ Data sharing: allow many users to access to a common data base
❖ Resource Sharing: expensive peripherals like color printers
❖ Communication: enhance human – to - human communication, e.g., email, chat
❖ Flexibility: spread the workload over the available machines
Limitations of Distributed platform:
❖ a. A distributed system is a set of computers that communicate over a network, and do not
share a common memory or a common clock.
❖ b. Absence of a common (global) clock
I. No concept of global time
II. It’s difficult to reason about the temporal ordering of events
1. Cooperation between processes ( e.g., producer /consumer, client/server)
2. Arrival of requests to the OS (e.g., for resources)
3. Collecting up – to - date global state
c. It’s difficult to design and debug algorithms in a distributed system
✓ Mutual exclusion
✓ Synchronization
✓ Deadlock
❖ Absence of shared memory
➢ “State” is distributed throughout system
➢ One process can get either.
✓ A coherent but partial view of the system.
✓ Or an incoherent but complete (global) view of the system
➢ Where coherent means
✓ All processes make their observations at the same time
➢ Where complete (or global) includes:
✓ All local views of the state, plus
✓ Any messages that are in transit
Q8: Write different clock synchronization and leadership algorithms for distributed Platforms.

Clock synchronization is a topic in computer science and engineering that aims to coordinate
otherwise independent clocks. Even when initially set accurately, real clocks will differ after some
amount of time due to clock drift, caused by clocks counting time at slightly different rates. There are
several problems that occur as a result of clock rate differences and several solutions, some being
more appropriate than others in certain contexts.

In serial communication, clock synchronization can refer to clock recovery which achieves frequency
synchronization, as opposed to full phase synchronization. Such clock synchronization is used in
synchronization in telecommunications and automatic baud rate detection.

Clock synchronization algorithms have two categories

4. Distributed algorithms
❖ There is no particular time server.
❖ The processors periodically reach an agreement on the clock value by averaging the time of
neighbors’ clock and its local clock.
❖ This can be sued if no UTC receiver exists (no external synchronization is needed). Only
internal synchronization is performed.
❖ Processes can run on different machines and no global clock to judge which event happens
first.
5. Centralized Algorithms
❖ There exists one particular node, the so called time server node and clock time of this node is
used as reference.
❖ Passive time server: the other machines ask periodically for the time. The goal is to keep the
clocks of all other nodes synchronized with the time server.
❖ Active time server: the time servers active, broadcasting other machines periodically about
the time
❖ Disadvantages: single point of failure i.e. less reliable. Pr

Leadership is a lot about believes and decision-making. In the following I explain based on different
believe the resulting decision-making modes of the three base style concepts.

1- autocratic style: I am in charge, I need to be in control, I decide,

2- democratic style: everyone in the team has something to contribute, I need to consult to tap into
their potential, we decide together, and
 3- Laisser-faire style: I have hired smart professionals and they should be the ones to do the job
best, with minimal consult and no interference from my side, my role is mainly to recruit the
right people and monitor performance.

The leader election is important problem in distributed system as data is distributed among different
node which is geographically separated. Designating a single node as an organizer in distributed
systems is a challenging issue that calls for suitable election algorithms. In distributed systems, nodes
communicate with each other using shared memory or via message passing. To execute any
distributed task effectively
Many distributed election algorithms have been proposed to resolve the problem of leader election.
Among all the existing algorithms, the most prominent algorithms are as:
❖ Bully Algorithm presented by Gracia-Molina in 1982.
❖ Ring Algorithm
A) Bully Algorithm
➢ Each process has a unique numerical ID
➢ Processes know the Ids and address of every other process
➢ Communication is assumed reliable
➢ Key Idea: select process with highest ID
➢ Process initiates election if it just recovered from failure or if coordinator failed
➢ 3 message types: election, OK, I won
➢ Several processes can initiate an election simultaneously
– Need consistent result
O(n2) messages required with n processes

B) Ring Algorithm
➢ Processes have unique Ids and arranged in a logical ring
➢ Each process knows its neighbors
– Select process with highest ID
 ➢ Begin election if just recovered or coordinator has failed
➢ Send Election to closest downstream node that is alive
– Sequentially poll each successor until a live node is found
➢ Each process tags its ID on the message
➢ Initiator picks node with highest ID and sends a coordinator message
➢ Multiple elections can be in progress
– Wastes network bandwidth but does no harm

Ring algorithm examples

Q9: Write a short note on evolution of distributed programming with proper references.
A computer program that runs in a distributed system is called a distributed program, and distributed
programming is the process of writing such programs. There are many alternatives for the message
passing mechanism, including pure HTTP, RPC-like connectors and message queues
A distributed programming system is a realization of a distributed programming language What’s hard
is distributed debugging. There are just way too many moving parts to worry about, and too many
asynchronous and intermittent events floating around. And the debugging tools are incredibly crude. (It’s not
like you can single step through code in a controlled environment and do anything useful.)
On the other hand, if you architect your system well, and build in checkpoints and other error handling
mechanisms, you can avoid a lot of those tricky bugs. Now, if, by “distributed programming,” you mean a
distributed team of programmers. Then you’re into the world of management and team communication
issues - a whole different thing entirely.
Distributed programming is following design and implementation principles:
1. Maximal network transparency
The Protocol Infrastructure:
• Network transparency meant that we had to take into account that all language entities that in
the concurrent centralized system could be shared between threads on the same machine
could now be shared between threads on different machines.
❖ This meant that we had to, for many of the language entities, devise or find protocols (or
distributed algorithms) that would coordinate operations on sites that reference the entity.
❖ Clearly, we wanted the most efficient (in terms of messages and network hops) without
scarifying semantics (consistency).
❖ An important design principle in the work was not to rely on any kind of central authority or
out-of-band service. This can be formulated precisely
2. Good Network awareness
❖ Here we are concerned with the non-functional properties of the system. We consider
performance and failure issues
❖ Network-awareness covers system aspects properties that make the system predictable in the
terms of performance, failure, etc. It also covers system properties that give the programmer
the necessary control to adapt and optimize the application depending on deployment,
expected usage patterns, etc. This control aspect of network-awareness requires that the
system is reasonably efficient and fault tolerant to begin with.
3. Efficient local execution
❖ A major design constraint was that operations on local language entities (i.e. only referenced
from a single site) should be affected as little as possible. Ideally there would be no difference
in performance in Mozart as compared to centralized Oz.
❖ In practice, the design constraint that we worked with was that operations on entities that are
at operation-time local should be virtually unchanged. This means that the performance of
operations on an entity is independent of the entity’s history. This requires the cooperation of
the distributed garbage collector.

Problems of Distributed Programming

There are problems that exist in distributed system environments that do not exist in single-machine
environments. Partial failure, concurrency, and latency are three problems that make distributed
computing fundamentally different from local computing.

In order to understand the design decisions behind programming languages and systems for
distributed computing, it is necessary to discuss these three problems that make distributed computing
unique. In this section, we present an overview of these three problems and their impact on
distributed programming models.

Partial Failure
❖ In the case of a crash on a local environment, either the machine has failed (total failure), or
the source of the crash can be learned from a central resource manager such as the operating
system. (Waldo, Wyant, Wollrath, & Kendall, 1997) If an application consists of multiple
communicating processes partial failure is possible, however because the cause of the partial
failure can be determined, this kind of partial failure can be repaired given the operating
system’s knowledge.
❖ For example, a process can be restored based on a checkpoint, another process in the
application can query the operating system about the failed process’ state, etc. Because failure
in a distributed setting involves another player, the network, it is impossible in most cases to
determine the cause of failure
Consistency (Concurrency)
❖ If computing on shared data can be avoided, parallel computations will not be bottlenecked by
serialized accesses. Unfortunately, there are many instances where operating on shared data is
necessary.
❖ While problems with shared data can be dealt with fairly simply in the local case, distribution
introduces problems that make consistency more complex.
❖ In local computing, enforcing consistency is fast and straightforward. Traditionally, a piece of
data is protected by another piece of data called a lock

Latency
❖ Is another major problem that is unique to distributed computing. Unlike the other problems
discussed in this section, latency does not necessarily affect program correctness. Rather, it is
a problem that impacts application performance, and can be a source of non determinism.
❖ In the case of local computing, latency is minimal and fairly constant. Although there may be
subtle timing differences that arise from contention from concurrent processes, these
fluctuations are relatively small. As well, machine hardware is constant. There are no changes
to the latency of communication channels on a single machine.
Q10: Describe the current limitations and Strengths of leading distributed computing platforms
with proper references
1. Why distributed computing?
❖ „ Economics: distributed systems allow the pooling of resources, including CPU cycles, data
storage, input/output devices, and services. „
❖ Reliability: a distributed system allows replication of resources and/or services, thus reducing
service outage due to failures.
❖ Speed: a distributed system may have more total computing power than a mainframe.
➢ Ex.: 10,000 CPU chips, each running at 50 MIPS. Not possible to build 500,000 MIPS
single processor. Enhanced performance through load distributing.
❖ Incremental growth: Computing power can be added in small increments. This leads to
Modular expandability „
❖ The Internet has become a universal platform for distributed computing.
In any form of distributed computing, there is always a tradeoff in limitation and Strengths.
Some of the reasons for the popularity of distributed computing strengthen: „
➢ The affordability of computers and availability of network access „
➢ Resource sharing „
➢ Scalability „
➢ Fault Tolerance
The Limitation of distributed computing: „
Multiple Points of Failures: the failure of one or more participating computers, or one or more
network links, can spell trouble. „
Security Concerns: In a distributed system, there are more opportunities for unauthorized attack.
References

1). Tony Mason, 30+ years developing systems software (UNIX, Windows (April 19 2017)
([Link]

G. Allen, T. Dramlitsch, I. Foster, N.T. Karonis, M. Ripanu, E. Seidel, and B. Toonen.

Supporting efficient execution in heterogeneous distributed computing environemnt with

Cactus and Globus. In Proceedings SuperComputing 2001, Denver, USA, November 2001.
Challenges and Future Trends of Distributed Computing Systems

[Link]

[Link]/files/[Link]

9). [Link]

▪ The Design Philosophy of Distributed Programming Systems: the Mozart Experience

▪ [Link]

10). Distributed Computing Introduction, M. Li

[Link]/babaoglu/papers/pdf/[Link]

▪ [Link]