Overview

This chapter discusses client/server (C/S) software engineering. Client/server software engineering blends conventional principles, concepts, and methods discussed earlier in the text with elements of object-oriented and component-based software engineering. C/S architectures dominate the landscape of computer-based systems. In C/S architectures, software residing on one computer (the client) requests services or data from another computer (the server). The process model used in C/S software engineering is evolutionary beginning with requirements elicitation. Functionality is allocated to subsystems of components that are assigned to either the client or the server side of the C/S architecture. Design focuses on integration of existing components and creation of new components. Implementation and testing must exercise both the client and server functionality within the context of the component integration standards and the C/S architecture. C/S software engineering relies on the same SQA practices as other software engineering processes. Formal technical reviews are used to assess the quality of the analysis and design models. Specialized reviews consider issues associated with component integration and middleware. Testing is used to uncover errors at the component, subsystem, client, and sever levels.

Representative Client/Server Systems

• File servers (client requests selected records from a file, server transmits records to client over the network)
• Database servers (client sends SQL requests to server, server processes the request and returns the results to the client over the network)
• Transaction servers (client sends requests that invokes remote procedures on the server side, sever executes procedures invoked and returns the results to the client)
• Groupware servers (server provides set of applications that enable communication among clients using text, images, bulletin boards, video, etc.)

Software Components for C/S Systems

• User interaction/presentation subsystem (handles all user events)
• Application subsystem (implements requires defined by the application within the context of the operating environment, components may reside on either the client or server side)
• Database management subsystem (performs data manipulation and management for the application)
• Middleware (all software components that exist on both the client and the server to allow exchange of information)

Representative C/S Configuration Options

• Distributed presentation - database and application logic remain on the server, client software is used to reformat server data into GUI format
• Remote presentation - similar to distributed presentation, primary database and application logic remain on the server, data sent by the server is used by the client to prepare the user presentation
• Distributed logic - client is assigned all user presentation tasks associated with data entry and formulating server queries, server is assigned data management tasks and updates information based on user actions
• Remote data management - applications on server side create new data sources, applications on client side process the new data returned by the server
• Distributed databases - data is spread across multiple clients and servers, requiring clients to support data management as well as application and GUI components
• Fat server - most software functions for C/S system are allocated to the server
• Thin clients - network computer approach relegating all application processing to a fat server

Guidelines for Distributing Application Subsystems

• The presentation/interaction subsystem is generally placed on the client.
• If the database is to be shared by multiple users connected by a LAN, the database is typically located on the server.
• Static data used for reference should be allocated to the client.

Linking C/S Software Subsystems

• Pipes (permit messaging between different machines running different operating systems)
• Remote procedure calls (permit process running on one machine to invoke execution of process residing on another machine)
• Client/server SQL interaction (SQL requests passed from client to server DBMS, this mechanism is limited to RDBMS)

Representative Middleware Architectures

• CORBA (ORB)
• COM (Microsoft)
• JavaBeans (Sun)

Design Issues for C/S Systems

• Data and architectural design - dominates the design process to be able to effectively use the capabilities of RDBMS or OODMBS
• Event-driven paradigm - when used, behavioral modeling should be conducted and the control-oriented aspects of the behavioral model should translated into the design model
• Interface design - elevated in importance, since the user interaction/presentation component implements all functions typically associated with a GUI
• Object-oriented point of view - often chosen, since an object structure is provides by events initiated in the GUI and their event handlers within the client-based software

Architectural Design for Client/Server Systems

• Best described as communicating processes style architecture whose goal is to achieve easy scalability when adding and arbitrary number of clients
• Since modern C/S systems tend to be component-based, an object request broker (ORB) architecture is used for implementation
• Object adapters or wrappers provide service to facilitate communication among client and server components

• component implementations are registered
• all component references are interpreted and reconciled
• component references are mapped to corresponding component implementations
• objects are activated and deactivated
• operations are invoked when messages are transmitted
• security features are implemented

C/S Design Repository Information

• Entities (from ER diagram)
• Files (which implement entities)
• File-to-field relationship (establishes file layout)
• Fields (from data dictionary)
• File-to-file relationships (related files that may be joined together)
• Relationship validation
• Field type (used to permit inheritance from super classes)
• Data type (characteristics of field data)
• File type (used to identify file location)
• Field function (key, foreign key, attribute, etc.)
• Allowed values
• Business values (rules for editing, calculating derived fields, etc.)

Data Distribution and Management Techniques

• Relational data base management systems (RDBMS)
• Manual extract (user allowed to manually copy data from server to client)
• Snapshot (automates manual extract by specifying a copy of the data be transferred from the client to the server at predefined intervals)
• Replication (multiple copies of data are maintained at different sites)
• Fragmentation (system database is spread across several machines)

C/S Design Approach

1. For each elementary business process, identify the files created, updated, referenced, or deleted.
2. Use the files from step 1 as basis for defining components or objects.
3. For each component, retrieve the business rules and other business object information that has been established for the relevant file.
4. Determine which rules are relevant to the process and decompose the rules down to the method level.
5. As required, define any additional components that are needed to implement the methods.

Process Design Entities

• Methods - describe how a business rule is to be implmemented
• Elementary processes - business processes identified in the analysis model
• Process/component link - identifies components that makeup the solution for an elementary business process
• Components - describes components shown on structure chart
• Business rule/component link - identified components significant to implementation of a given business rule

C/S Testing Strategy

• Application function tests (client applications tested in stand alone manner)
• Sever tests (test coordination and management functions of server, also measure performance of server)
• Database tests (check accuracy and integrity server data, examine transactions posted by client, test archiving)
• Transaction testing (ensure each class of transactions is processed correctly)
• Network communication testing (verify communication among network nodes)

C/S Testing Tactics

• Begins with testing in the small and then proceeds to integration testing using the non-incremental or big bang approach
• Requires special attention to configuration testing and compatibility testing
• OO testing tactics can be used for C/S systems (even when system was not built using OO methodology)
• GUI testing requires special techniques in C/S systems (e.g. structured capture/playback)