Chapter 12 Review

Chad HagstromCS 310

Spring 2008

Concepts Overview

Primary Concepts:

* The reasons for (and advantages of) distributed systems

* Description of client-server architectures

* Description of distributed object architectures

* Examination of “inter-organizational distributed computing”

Distributed Systems

* This is a software system consisting of several smaller interoperating pieces that each execute on their own separate computer (or processor).

Advantages:

* It can use the resources of multiple computers simultaneously.

* The pieces usually communicate via some standard network protocol.

* The pieces can perform their operations in parallel.

* The addition of new pieces is achievable by inserting another computer (with its software piece) into the same network.

* If one piece malfunctions, other pieces may be designed to act as backups to keep the system running continuously.

Distr. Systems (cont'd...)

Disadvantages:

* Distributed systems are usually harder to implement.

* It is harder to keep such systems secure because of their network communication.

* The process of handling the interoperability of the pieces is more complex.

* The system's responsiveness cannot be predicted accurately in many situations.

Multiprocessor Systems

* Consists of several different pieces that each constitute a different process.

* Each process could possibly be running on its own individual processor, but such a situation is not required.

* This architecture could allow for processes that perform their actions in parallel, which increases efficiency in general.

Client-Server Systems

* Consists of server processes (which provide various services to other processes) and client processes (which are the consumers of such services).

* Clients have to be able to locate servers in order to interact with them, but the converse is not necessarily true.

Usually consists of a 3-layered architecture:

* Presentation Layer: Allows users to send commands to the system and to view system results.

* Application Processing Layer: Handles & processes user commands, retrieves and processes system data, sends updates to the user, etc.

* Data Management Layer: Handles the system's data storage and data operations.

2-Tier Client-Server Systems

There are 2 main ways to divide three layers among two processes:

* Thin-Client Model: Clients just have the presentation layer, while the server(s) have the application processing and data management layers.

* Fat-Client Model: Clients have the presentation and application processing layers, while the server(s) just have the data management layer.

* The thin-client model is less complex to implement in most cases, but it severely taxes the server(s) and usually requires more network data transmission (which taxes the network as well).

* The fat-client model reduces server workload and distributes more of the processing to the clients, but major application modifications may require clients to perform a complete system reinstallation.

3-Tier Client-Server Systems

* Unlike 2-tier systems, these systems divide 3 layers among 3 processes.

* Client processes handle the presentation layer, one server process (or group) handles the application processing layer, and a different server process (or group) handles the data management layer.

* This approach is less taxing on servers and the network compared to the thin-client model, and updates to the application processing are usually less complex and cheaper compared to the fat-client model.

Distributed Object Systems

* Instead of separating processes into producers of services and consumers of services, this system type treats processes as objects which can both produce and consume services.

* These objects use an “Object Request Broker” (or “Software Bus”) to send and receive requests to each other.

* Such systems are typically more flexible than client-server systems since objects can produce and consume services, but system complexity is increased.

CORBA

* CORBA is a standard that defines a particular set of services for an ORB to provide.

Some of the requirements specified by this standard are these:

* Objects using a CORBA broker can be language-independent, but they must utilize something called “IDL (Interface Definition Language).”

* The ORB must not only forward service requests; it must also notify the sending object of the outcome.

* Certain services (like “directory services, transaction services...”) must be provided by some of the system's CORBA objects.

Inter-Org. Distr. Computing

* Refers to systems that are distributed not only across multiple processes but also between multiple individuals and organizations.

Two such models are:

* Peer-To-Peer Architecture: an inter-organizational system which is either completely decentralized (meaning there is no such thing as a “client” or a “server”), or is semi-centralized (meaning a few servers do exist to assist in coordination among peers).

Service-Oriented Architecture: an inter-organizational system that allows many different services to be accessed from various pieces of the system, normally by means of some standard protocol (like HTML, SOAP, etc.).

Conclusion

My new perspectives on Chapter 12:

* The realization of how much more complex my CS 310 and senior project would be without considering distributed architecture situations.

Application of Chapter 12 to my project:

* My current design divides the main system into a two-processor architecture.

References

* Ian Sommerville's Software Engineering (8th ed)

* Professor Carol Shilepsky's PowerPoint slides at aurora.wells.edu