Intro

It is a pattern of component types and their interactions.
Define constraints: how things are allowed to interact.
Architectural pattern is synonym for style.
Defining features:
- Component types: e.g data store, processes etc.
- Component layout: e.g. which process is allowed to access data store.
- Connectors: e.g how are they connected ? RPC, Data stream ?
- Constraints: On components - e.g. data store cant modify itself, On connections - no P2P communication allowed.

Data Centred

Characterised by the access/update of a central data store.
The data store can be passive (e.g. a file) or be active (e.g. blackboard)
Good for integration and extensibility. There is a low coupling - only the data is shared.
E.g. Transactional DB, Blackboard, CASE Tools.

If the current state of the central data is the main trigger for processes to execute, then the repository can be a blackboard.
A common knowledge base, the "blackboard", is iteratively updated by a diverse group of specialist knowledge sources, starting with a problem specification and ending with a solution.
Each knowledge source updates the blackboard with a partial solution when its internal constraints match the blackboard state.
In this way, the specialists work together to solve the problem.
Invocation of a KS is triggered by the state of the blackboard.

Characterized by viewing the system as a series of transformations on successive pieces of input data.
Orderly motion of data. Explicit pattern of data flow.
No direct interactions b/w components.
Objectives: Modifiability - plug in/out components. Reusability - sequence of components plugged together.

Similar to batch sequential, except that the computations (filters) work incrementally on the data.
Data is immediately passed - i.e. it is streamed and not batched.
No state is retained between computations.
Pipes carry data from output of one computation (filter) to another.
e.g. Unix Shell - ls | grep "java" | wc -l
Advantages:
- Simple, easy to reuse - a pipe and filter system can be made into another filter.
- Support concurrency.
Disadvantages:
- Filters operate as a separate process (process overhead). They cannot cooperate.
- Lowest common denominator of data has to be used for data stream - e.g. ASCII text.

Main goal is to achieve portability.
A virtual machine is a software style that simulates/provides interface to functionality of underlying hardware/software platform.
biggest e.g JVM.
Running program through an interpreter adds flexibility through the ability to interrupt and query program and introduce changes at runtime. But there is a performance penalty.
Virtual machine structure. The interpreter selects an instruction, updates its internal state and based on instruction potentially updates the program's data.

Components are assigned to layers to control component interaction.
Each level communicates with only its immediate neighbours, Layer N can use services of only layer N-1 and delegates subtasks to it.
Goal is to achieve qualities of modifiability and portability.
There can be a relaxed layer - where a layer talks to layers other than immediate neighbours.

Most common e.g. is the OSI protocol stack.
Advantage
- Increased levels of abstraction.
- Confinement of change - change can max affect to other layers.
Disadvantage:
- Difficult to structure systems in layers.
- Performance may require closer coupling between higher layers and lower layers.

Components announce data they wish to share (publish) with their environment - a set of unnamed components.
Other components may register an interest in the class (subscribe).
Typically a message manager manages communication - providing the decoupling between the publisher and the subscriber.

Processes communicate directly.
Single machine - signals.
Multiple machines - RPC. TCP etc.
classic e.g. client server architecture. Server works synchronously or asynchronously (meaning client has his own thread of control).