1. Lecture 22: Client-Server Software Engineering

2. Today’s Topics Basic Principles of C/S Systems
Configurations, Subsystem Linking
Object Request Broker (ORB)
SE Paradigms for C/S Systems
Testing C/S Systems

3. Client-Server SE “A dominant architecture for information processing”
Collective result of many improvements in computing:
Network bandwidth
Database technology
Internet & WWW
What are the related SE issues?

4. Basic Elements Root System Servers Network Clients (individual PCs)
Mainframe or DB server
Repository for corporate data
Servers
Update & request corporate data
Implement departmental systems
Network
Connectivity via LAN, WAN, Internet
Clients (individual PCs)

5. Generic Client-Server Architecture
[From SEPA 5/e]

6. Client-Server Options
File Servers file request / data response
Database Servers SQL request / table response
Transaction Servers remote procedure request
Groupware Servers client connectivity
[From SEPA 5/e]

7. C/S Software Components
“Several distinct subsystems that can be allocated to client or server”
“Distributed among machines” multi-tier, networked architecture

8. Components [2] Classic 3-tier architecture:
User interaction/presentation subsystem
Application subsystem
Database management subsystem
Web
Browser
Server DB
Java
Servlet
Client 1
Server 1
Server 2
Web Example

9. Middleware Software components that exist on both client & server:
Networking (e.g., TCP/IP)
Application Connectivity (e.g. HTTP, CORBA)
“The nervous system of a client-server system” [Orfali, et al. ’99]

10. Distributing Functionality
Fat Server design most functionality on the server e.g., file server, DB server
Fat Client design most functionality on the client e.g., message forwarding system

11. Distributed Configurations
Distributed Presentation client handles display only
Remote Presentation client prepares display from data
Distributed Logic client handles data entry & update
Remote Data Management client processes data (e.g. DSS)
Distributed Databases client manages data

12. Guidelines Presentation on the client Shared DBs on a server
Windows/PC-based
Offload GUI processing to client
Shared DBs on a server
DBMS, physical database
Static / frequently-used data stored on the client
Minimize unnecessary network traffic

13. Linking C/S Subsystems
Pipes (Unix-based)
One process can share data with another (across machines, OS)
Remote Procedure Call (RPC)
One process can invoke another (across machines, OS)
Client/Server SQL
A process can query / update data from a central RDBMS

14. Web Linking Hypertext Transfer Protocal (HTTP)
Web browser can retrieve data (HTML) from a web server
Common Gateway Interface (CGI)
Web browser can invoke a process (script, servlet, etc.) on a web server

15. Object Request Broker Middleware
Coordinates message-passing between client and server objects
Finds location of server object(s)
Invokes method(s)
Returns resulting data to client
Examples: COM, CORBA, EJB

16. ORB Client/Server Connectivity
[Vogel & Duddy, ’98]
Stubs give a client a generic way of requesting services, regardless of how the client is implemented
Skeletons give a server a generic way to provide services, regardless of how they are implemented

17. CORBA Architecture
[Orfali & Harkey ’98]

18. CORBA Architecture [From SEPA 5/e]
IDL: Interface Description Language (objects, attributes, & methods)
IDL stubs act as a gateway for C/S communication
Object implementations are hidden, can vary (Java, C++, etc.)

19. SE Paradigms for C/S Systems
Many are possible, two are common:
Evolutionary Paradigm
Event-based and/or object-based
Component-Based Paradigm
COTS & in-house components
Or, some hybrid of both…

20. Analysis Modeling
Constraints of the design & implementation can influence analysis phase e.g., qualification step from CBSE e.g., architectural constraints

21. Design Phase Data & architectural design dominate the process
Behavioral modeling important for event-driven systems
User interface design a key activity for client side
Object-oriented approach is usually the most appropriate

22. Architectural Design Key criterion: scalability
Synchronous vs. asynchronous communication
ORB architecture can be used as an adaptive infrastructure for integrating multiple COTS modules

23. Sharing Data with the Client
Manual extract User initiates a static, local copy
Snapshot Automatic extraction of local copy
Replication Fully-coordinated, real-time duplication
Fragmentation Distributed storage of virtual DB

24. Designing a C/S Business Process [Porter ’95]
Identify files created, updated, referenced, deleted
Define components or objects
For each component, define business rules & information
Decompose rules down to methods
Define additional components necessary to support the methods

25. Structure Chart Notation [Porter ‘95]
[From SEPA 5/e]

26. Testing Issues Distributed software is difficult to test! Client GUI
Environment / platform diversity
Networked databases
Distributed processing
Non-robust target environment
Non-linear performance relationships

27. Testing Phases Clients tested in isolation
Client & server tested in isolation (test or dummy networking)
Complete architecture is tested (including network & real-time performance)

28. Types of Tests
Application function tests client functionality, standalone
Server tests response time, throughput
Database tests accuracy, integrity, archiving
Transaction tests correctness, performance
Network communication tests connectivity, traffic, security

29. Operational Profile Common usage patterns Abnormal usage patterns
Vary per user, time period, task, etc.
Based on user scenarios
Abnormal usage patterns
Average- vs. worst-case performance
Malicious attacks (web systems)
Global Expectations
maximum acceptable downtime, delay, etc.

30. Questions?