Distributed Software Engineering with Client-Server Computing

Yasir Rehman 429
Haseeb ur Rehman 434
Arsalan Khalid 436
Usama Zafar 437
Nasir Nazir 438
Awais Shafeeq 439

The Distributed Software Engineering is a branch
of Software engineering which deals with the
study of the collection of independent software
systems that appear to the user as a coherent
system.

Basic aim to use this type of software development is as follows;
1. Development becomes Fast
2. Minimal Faults
3. Not much burden on a single machine as the work is divided in chunks
Virtually all large computer-based systems are now distributed systems.
A distributed is system is one involving several computer systems working
coherently and in chunks for a single objective. This technique is being
used in many organizations around the globe.
e.g. Free Lancing on Web Sites etc

Salient features of Distributed Software Engineering
are given below;
 Resource Sharing.
Sharing of hardware and software resources.
 Openness.
Use of equipment and software from different
vendors.
 Concurrency.
Concurrent processing to enhance performance.
 Scalability.
Increased throughput by adding new resources.
 Fault Tolerance.
The ability to continue in operation after a fault has
occurred.

The key objectives which are on the back
of developing a distributed software are
as follows;
 Agility:
Key feature behind this type of
development is the agility which it
provides to develop software. Work is
done simultaneously in chunks and to
provide maximum advantage to the
developing team.

 Dynamic testing:
As the program is being monitored
and developed on many other machines
and developers, it is dynamically tested in
all sections from which it undergoes.
 Multiple Interactions:
In case of C/S like systems,
multiple users can interact with the same
database simultaneously without any
breakage.

 Timely development:
When software is developed on
multiple places in one time, it needs less
time as compared to the same software
being developed on a single machine.
 Fault Tolerance:
If a component of software being
developed or a program being used shuts
down, it does not affect the other
components being developed. A
developer can debug that error
afterwards.

 Diversification:
The approach of the users and
the developers diversifies when
components from different environment
are molded together to built a large
software and developers interact there
thoughts by sharing their work with each
other.

Basically there are eight main issues we have to
handle while developing a distributed system;
 Transparency:
Ideally, users should not be aware that a system
is distributed and services should be
independent of distribution characteristics.
 Authentication:
Authentication is the process in which client is
confirmed it’s identity weather he/she can do
that specific task. He / She has rights to do the
specific task. It can be done through many
ways. Some of which are as follows:
› Login-Password.
› IP Address.

 Fault tolerance:
The ability of a system to respond gracefully to
an unexpected hardware or software failure.
 Network Reliability:
A good distributed software network may
contain following aspects;
› Latency is zero.
› Bandwidth is infinite.
› The network is secure.
› Topology doesn't change.
› There is one administrator.
› Transport cost is zero.
› The network is homogeneous

 Synchronization:
Synchronization refers to the idea that multiple
processes are to join up or handshake at a
certain point, in order to reach an agreement or
commit to a certain sequence of action.
 Security:
Difficulties in a distributed system arise because
different organizations may own parts of the
system. These organizations may have mutually
incompatible security policies and security
mechanisms. Developers need to ensure that
the product they are designing is secured from
any outside attacks, Interception as well as
Interruption.

 Quality of Service:
The quality of service offered by a
distributed system reflects the system’s
ability to deliver its services dependably
and with a response time and throughput
that is acceptable to its users.
 Failure Management:
In a distributed system, it is inevitable that
failures will occur, so the system has to be
designed to be resilient to these failures.

Except those, there are other sub-Issues as
well;
› Data Propagation
› Overhead of Communication Protocols
› Load Distribution
› Recovery Procedure
› Consistency
› Scalability

Client-Server computing is the logical
extension of modular programming with
fundamental assumption that separation
of a huge program into its constituent
parts ("modules") can create the
possibility for further modification, easier
development and better maintainability.
In Client-Server Computing, all large
modules need not all be executed within
the same memory space.

Basically three components are there on
which this system constitutes;
 Client
A Client Server Process usually
manages the user-interface portion of
the application; validate data entered
by the user, dispatch requests to server
programs.

 Server
On the other hand, the Server Process fulfills
the client request by performing the service
requested. After the server receives requests
from clients, it executes the Database
Retrieval updates and manages data
integrity and dispatches responses to client
requests.
 Middleware
Middleware allows applications to
transparently communicate with other
programs or processes regardless of
location.

There are four basic characteristics of Client/Server computing;
 Combination of a client or front-end portion that interacts with
the user, and a server or back-end portion that interacts with
the shared resource.
 The front-end task and back-end task have fundamentally
different requirements for computing resources such
as processor speeds, memory, disk speeds and capacities, and
input/output devices.
 The environment is typically heterogeneous and multivendor.
The hardware platform and operating system of client and
server are not usually the same. Client and server processes
communicate through a well-defined set of standard
application program interfaces (API's) and RPC's.
 An important characteristic of client-server systems is
scalability. They can be scaled horizontally or vertically.
Horizontal scaling means adding or removing client

Tremendous benefits for implementing Client-Server
Technology in Business. Below are just a few of it.
 Vendor independence as compared to the traditional
mainframe computing. This includes application
development methodologies, programming paradigms,
products and architectures.
 Organization has changed from steep hierarchies to
flattened hierarchies. Decisions making are carried out by
many lower ranked managers across the organization
rather than performed only by CEOs in the past.
 Network management is replacing vertical management

 Faster response and flexibility to changing environment of
business world outside.
 The customer has a single point of contact for all business
with the organization.
 The time required to complete the work will be minimized
 Better sharing of critical database resources and other
application software among clients through the network.
 Companies can cut costs on maintenance in employing
Client- Server Computing since servers are usually cheaper
than mainframe (1/10 of mainframe) and the
performance of servers and mainframe are nearly
identical.

Precisely, the distributed software
development technique is quite
profitable and fast-developing among
other techniques and is being adapted
in many organizations across the globe.
Though it has some concerns regarding
security and transparency of the
product, but nothing is perfect in this
world I suppose…

Distributed Software Engineering with Client-Server Computing

Distributed Software Engineering with Client-Server Computing

More Related Content

What's hot

Viewers also liked

Similar to Distributed Software Engineering with Client-Server Computing

Recently uploaded

Distributed Software Engineering with Client-Server Computing