For the process application described below create a preliminary layered architecture.

A manufacturing process must maintain the pH of a solution in a vat within certain bounds. The pH of the vat is monitored by taking samples every 12 minutes using six pH sensors located at various places in the vat. The samples are stored, and every 12 minutes a control chart is produced showing a moving window of the most recent sample means. The control chart displays between 10 and 40 data points, along withquality control statistics. Its parameters are set by the user.The program displays and evaluates the control chart, as well as flagging the out-of-control points (data points indicating that the process may be out of control).The program stores all data permanently in data files for later analysis. Each data file contains one days pH readings, along with the times the readings were taken.The program redraws the control chart every 12 minutes. It is also redrawn whenever the user changes any of the parameters governing the chart.This program must be highly reliable. It must accommodate several kinds of pH sensors and allow new brands of sensors to be introduced later. Control charts are an established technique for monitoring industrial processes and are not likely to change.

Use this information to help you to solve it:

Layered Architectures is:

Architectural Layers

The program is divided into an array of modules or layers or groups

Each layer provides services to the layer above and makes use of services provided by the layer below

Every layer is a module that provides a cohesive set of services and has a well-defined interface

Every program unit must be in exactly one layer

The Layered style is among the most widely used of all architectural styles

Types of Applications

Suitable for applications that involve distinct classes of services that can be organized hierarchically

Components (modules)

Typically collections of operations or procedures

Connectors

Typically operation or procedure calls (with restricted visibility).

Layer Constraints

Static structure: Software is partitioned into layers that provide a cohesive set of services with a well-defined interface (linear structure)

Dynamic structure: Each layer is allowed to use the services of only the layer(s) below it. It also provides a set of services to the layers above it. Interactions between layers is constrained (i.e. a layer can have no knowledge of the layers above it).

Dynamic can be further described as

Strict Layered style: Each layer can be constrained to use services of only the layer directly below it

Relaxed Layered style: Constraint is relaxed slightly to allow each layer to use all the layers below it.

Layers make good modules since they have the following characteristics:

Each layer is highly cohesive

Layers provide natural support for information hiding (i.e. DBMS)

Layers are constrained to use only lower layers (eliminate coupling of layers above them)

Layering helps dividing big problems into smaller separate modules (layers)

Easy to modify (i.e. changes made to one layer are independent of the rest of the program)

In fact, one can remove an entire layer and replace it with a functionally equivalent component

Layered architectures are highly changeable.

Layered Style example:

A citation management system records bibliographic citations searches them, and produces lists of references in a variety of bibliographic styles

Important Design Considerations:

Such programs must have user interfaces that are easily changed

They must also be able to incorporate new citation styles easily

The need to make the user interface easily changeable suggests that it should be a separate architectural component

Part of the program that formats citations should be separate from the part that stores, searches, and retrieves data

This suggests three major components:

User interface module

Citation formatter module,

Citation storage and retrieval module

Solution;

Clearly, user interface module must use services from the other two modules

In addition, citation formatter needs to use the storage and retrieval module

If we broaden the responsibilities of the citation formatter to include citation management responsibilities, then we have Strict Layered architecture

User Interface

Responsible for user interaction

Uses: Citation Management module to store, retrieve, and format citations

Citation Management

Responsible for keeping track of all citations and formatting them as required

When it needs to store, search, or retrieve citations, it does so using the Citation Storage and Retrieval module

Citation Storage and Retrieval

Uses some sort of persistent storage mechanism (i.e. database or IR system) to hold citation record.

Summary:

Citation records have fields for every kind of citation do not change often

Storage and retrieval functionality of the Citation Storage and retrieval is quite stable do not change often

Citation Management modules changes when new formatting styles are added to the program

This does not affect Citation Storage and Retrieval

This only affects User Interface module (extent for new styles must be added to the user interface)

User interface can change without any effect on the other two modules

Style Summary pattern:

Name: Layered

Application: Structure a program into an array of cohesive modules with well-dened interfaces to realize levels of abstraction, increase changeability, and increase reusability.

Form: The program is partitioned into cohesive modules with well-dened interfaces arranged in a chain or sequence from highest to lowest: the layers. Each layer is allowed to use only the layer immediately below it (Strict Layered style), or all the layers below it(Relaxed Layered style).

Consequences: Layers should be cohesive, hide information, be simple, and be coupled only to the layer or layers beneath them. All these characteristics make layers easy to alter or replace, improving changeability. The simplicity of a Layered architecture increases reliability and maintainability. Layers are likely to form reusable components. Layered programs may be hard to debug; program behavior must often be realized with communications across several layers, which may cause performance problems and be more work to program. It may be hard to form a good collection of layers.

Context: All complex systems experience the need to develop and evolve portions of the system independently. For this reason the developers of the system need a clear and well-documented separation of concerns, so that modules of the system may be independently developed and maintained.

Problem: The software needs to be segmented in such a way that the modules can be developed and evolved separately with little interaction among the parts, supporting portability, modifiability, and reuse.

Solution: To achieve this separation of concerns, the layered pattern divides the software into units called layers. Each layer is a grouping of modules that offers a cohesive set of services. The usage must be unidirectional. Layers completely partition a set of software, and each partition is exposed through a public interface.