CHS2546 Distributed and Client Server

Systems
Lecture 1 - What are Distributed Systems?

Lecture Plan:

What do we mean by distributed systems?

What are the characteristics of Distributed Systems?
An Example
The main problems
The Course Structure

Tutorial/Practical:

A Java Refresher in the Practical Lab.

What do we mean by distributed systems?

Distributed systems are now so widespread as to be ubiquitous. From cloud based

computing to the internet to distributed file systems, we use distributed systems all
the time.

Examples include:

Distributed Operating Systems

Distributed Applications
Distributed Databases

These are all loosely coupled distributed systems and are examples of the types of
systems we are interested in.

Tightly coupled systems such as array processors (i.e. those which

generally share memory) are of little interest on this course.

The World Wide Web is very loosely coupled distributed computing environment,
based on the transmission and reception of messages.
Bank Automatic Teller Machines (ATM) are components of another distributed
system.

The Sun Operating System, Solaris is another which offers distributed file storage
and process execution.

What are the characteristics of Distributed Systems?

These characteristics are taken from "Distributed Systems - Concepts and Design".
All distributed systems involve:

Networks - Distributed Systems are all networked one way or another,

hence
Communication - often message passing
Resource sharing - files, data, processors
Openness e.g. *NIX, Java, CORBA
Concurrency - components of the system may execute simultaneously
Scalability - increasing the size of a system should have no effect other than
an increase in performance or capacity.
High Availability and fault tolerance - achieved through the natural
redundancy of multiple replicated components.
Transparency
o Access
o Location
o Concurrency
o Replication
o Failure
o Migration
o Performance
o Scaling

An Example

An Air Ticket Booking System (Hypothetical)

The main problems

Taken from the same source. Distributed systems present various problems over
and above normal systems development:

Naming - we need some means of referring to objects uniquely, wherever

they are in our system. In the worst case the system could be the entire
Internet.
Communication - we need a high speed communication infrastructure which
supports the high level software structures we use.
Software Structure - for us this will almost always be object based, though
we will look at some non object based systems such as NFS and RPC
Load Balancing - we need to ensure that the processing capability of our
system is not overloaded and as fully utilised as possible as its workload
changes over time.
Maintaining Consistency - as soon as we introduce concurrency we need to
start worrying about consistency - ultimately we will need some form of
transaction based system to ensure consistency.

We will not be looking in depth at distributed (micro kernel) operating systems,

although they can form the basis for distributed applications.

About 10 years ago I said in my lecture notes Many authors believe that the near
future will see a lot of work based on distribution through replicated VM's on
heterogeneous hardware systems. This is the Java approach to distributed
computing.. This has turned out to be pretty accurate, but is not the only approach
to distribution.

The Course Structure

Initially we will be looking at some of the infrastructure needed for distributed

systems, in particular Remote Procedure Call (RPC) and its object oriented relative
Remote Method Invocation (RMI).

We will also look briefly at communication between processes mainly using

TCP/IP sockets.

With this infrastructure we will look at the provision of distributed services, e.g.
Sun's Network File system (NFS).
A major component of the course will be an investigation of Apache River as a
distributed application infrastructure, and the use of this to support a high level
framework such as JavaSpaces. These examples will allow us to look at the use of
transactions and at design patterns for distributed systems.

Other distribution mechanisms (focussing mainly on CORBA) will be considered

in the light of the facilities provided by Apache River.
We will be doing more with CORBA after Christmas when we cover Client Server
Computing.

We will discuss security issues and the provision of distributed database systems.

Finally, we will also look at Web Services and Semantic Web,although these are
not the main focus of this module as they are covered elsewhere in the department.