Client/Server Architectures

Pictures from, Software Engineering 8, Sommerville

System types Personal systems that are not distributed and

that are designed to run on a personal computer or workstation.

Embedded systems that run on a single processor or on an integrated group of processors.

Distributed systems where the system software runs on a loosely integrated group of cooperating processors linked by a network.

Distributed system characteristics 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.

Distributed system disadvantages Complexity

Typically, distributed systems are more complex than centralised systems.

Security More susceptible to external attack.

Manageability More effort required for system management.

Unpredictability Unpredictable responses depending on the system

organisation and network load.

Layered application architecture Presentation layer

Concerned with presenting the results of a computation to system users and with collecting user inputs.

Application processing layer Concerned with providing application specific functionality

e.g., in a banking system, banking functions such as open account, close account, etc.

Data management layer Concerned with managing the system databases.

Application layers

Presentation layer

Application processinglayer

Data managementlayer

Thin and fat clients Thin-client model

In a thin-client model, all of the application processing and data management is carried out on the server. The client is simply responsible for running the presentation software.

Fat-client model In this model, the server is only responsible for

data management. The software on the client implements the application logic and the interactions with the system user.

Thin and fat clients

Thin-clientmodel

Fat-clientmodel Client

Client

Server

Data managementApplication processing

Presentation

Server

Data management

PresentationApplication processing

Thin client model Used when legacy systems are migrated to

client server architectures. The legacy system acts as a server in its own right

with a graphical interface implemented on a client.

Used in data-intensive applications Web browsing

A major disadvantage is that it places a heavy processing load on both the server and the network.

Thin clients Text terminals

Client presents text to users, reads input from keyboard X windows

Protocol to exchange desktop window information Provides for the use of desktop applications that execute

on a server Server required to actual create graphical appearance and

transmit to client Very slow for wide-area networking

Traditional Web Browser Built on text terminal idea

Adds photographic images Adds hyperlinks

URLs point from one page to another Does not provide complete applications like XWindows Much faster than Xwindows

Allows Web to work on global scale

Xwindows versus Web Browser Xwindows

1. Server receives user input2. Server performs application processing3. Server puts computes changes required to GUI4. Server sends client GUI changes

Traditional Web Browser1. Server receives user input2. Server loads text and image resources for client3. Server provides a set of instructions for putting

resources together (HTML)4. Server sends client resources + instructions

Fat client model More processing is delegated to the client as

the application processing is locally executed. Most suitable for new C/S systems where the

capabilities of the client system are known in advance.

More complex than a thin client model especially for management. New versions of the application have to be installed on all clients.

Fat client examples

Online Multiplayer Games Multimedia Players Eclipse IDE Microsoft Outlook

Hybrid Browser Models

Server-Side Scripting JavaScript Java Applets

Hybrid Browser Models Server-Side Scripting

Instead of loading resources based on client request,Server loads resources based on application processing

Low latency at start-up time

Problem: High latency between user events

Hybrid Browser Models JavaScript

Client performs minor application processing but only related to beautifying the user interface Example: Drop down menus, drag and drop, etc...

Low latency at startup-time

Low latency between user events

Problem: Limited to GUI

Hybrid Browser Models Java Applets

Client downloads complete application on-demand

Application runs inside the browser Strong security, can’t execute machine instructions

directly

Low latency between user events

Problem: High latency at start-up time

A client-server ATM system

Account server

Customeraccountdatabase

Tele-processingmonitor

ATM

ATM

ATM

ATM

Three-tier architectures In a three-tier architecture, each of the application

architecture layers may execute on a separate processor.

Allows for better performance than a thin-client approach and is simpler to manage than a fat-client approach. More opportunities for caching Move slower components further away from clients to be

accessed only when necessary Middle-tier can further be split

Gives rise to multi-tier architecture Client – Web Server – Application Server – Data Management

Web server provides application routing to different applications hosted on different machines

A 3-tier C/S architecture

Client

Server

Datamanagement

PresentationServer

Applicationprocessing

New C/S Approaches Thin Clients

AJAX Fat Clients

Rich Clients

AJAX Asynchronous JavaScript and XML Event-based architecture

Asynchronous, concurrent, communication with server

For web browsers Which use Javascript

Client/Server communicate through XML messages Why?

Client loads large Javascript file at startup which contains most user interface instructions

Further communication with server doesn’t need UI information so HTML is redundant

AJAX Application processing is still on the server But ...

Client can process several events without loading new pages

Originally every interaction with server required a fresh web page to load

AJAX

Rich Clients Fat Clients with an automatic update feature Application is partitioned into core application

and other features through plugins Requires careful application decomposition If changes are require to core, user must

download whole new version Takes advantage of dynamic linked libraries

Modern compilers can linked together separately compiled class at application startup

Classes do not need to be compiled together

Use of C/S architectures

Architecture Applications

Two-tier C/Sarchitecture withthin clients

Legacy system applications where separating application processing anddata management is impractical.Computationally-intensive applications such as compilers with little orno data management.Data-intensive applications (browsing and querying) with little or noapplication processing.

Two-tier C/Sarchitecture withfat clients

Applications where application processing is provided by off-the-shelfsoftware (e.g. Microsoft Excel) on the client.Applications where computationally-intensive processing of data (e.g.data visualisation) is required.Applications with relatively stable end-user functionality used in anenvironment with well-established system management.

Three-tier ormulti-tier C/Sarchitecture

Large scale applications with hundreds or thousands of clientsApplications where both the data and the application are volatile.Applications where data from multiple sources are integrated.