Yasir Rehman 429

Haseeb ur Rehman 434

Arsalan Khalid 436

Usama Zafar 437

Nasir Nazir 438

Awais Shafeeq 439

Prof. Rana Ashraf Javed

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…