Upload
haseeb-rehman
View
96
Download
1
Embed Size (px)
DESCRIPTION
Presentation of Distributed software engineering with special example of client server computing...
Citation preview
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…