1. Client/Server Architectures
Pictures from, Software Engineering 8, Sommerville

2. 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.

3. 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.

4. 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.

5. 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.

6. Application layers

7. Thin and fat clients Thin-client model Fat-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.

8. Thin and fat clients T hin-client model F at-client Client Server
Data management
Application processing
Presentation

9. 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.

10. Thin clients Text terminals X windows Traditional Web Browser
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

11. Xwindows versus Web Browser
1. Server receives user input
2. Server performs application processing
3. Server puts computes changes required to GUI
4. Server sends client GUI changes
Traditional Web Browser
2. Server loads text and image resources for client
3. Server provides a set of instructions for putting resources together (HTML)
4. Server sends client resources + instructions

12. 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.

13. Fat client examples Online Multiplayer Games Multimedia Players
Eclipse IDE
Microsoft Outlook

14. Hybrid Browser Models
Server-Side Scripting
JavaScript
Java Applets

15. 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

16. 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

17. 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

18. A client-server ATM system

19. 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

20. A 3-tier C/S architecture

21. New C/S Approaches
Thin Clients
AJAX
Fat Clients
Rich Clients

22. 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

23. 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

24. AJAX

25. 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

26. Use of C/S architectures