Architectural Styles (by examples)

#architecture #design #styles #develop

The architecture of a system describes its major components, their relationships (structures), and how they interact with each other. Software architecture serves as a blueprint for a system. It provides an abstraction to manage the system complexity. Now we will look at the main architecural styles:

Pipe and Filter
Data-Centered
Layered
Client-Server
Model-View-Controller
Implicit Invocation
Microservices

First let's give a description of:

Components - calculation elements and elements for data storage. Communication with other elements is implemented through their interfaces (ports).
Connectors - the architectural elements for communication. Like the components communicate with other elements through their interfaces (roles).
Topology - Successful communication between 2 architectural the element occurs when a role is attached to a port and their interfaces are compatible. The architectural elements, their interrelationships and limitations, represent the topology.

Pipe and Filter

Definition

Pipe and Filter is architectural pattern, which has independent entities:

filters (components) - which perform transformations on data and process the input they receive
pipes (connectors) - which serve as connectors for the stream of data being transformed, each connected to the next component in the pipeline.

Description

The pattern of interaction in the pipe-and-filter pattern is haracterized by successive transformations of streams of data. As you can see in the diagram, the data flows in one direction. It starts at a data source, arrives at a filter’s input port(s) where processing is done at the component, and then, is passed via its output port(s) through a pipe to the next filter, and then eventually ends at the data target.

When used

Commonly used in data-processing applications (both batch and transaction-based) where inputs are processed in separate stages to generate related outputs.

Examples

The architectural pattern is very popular and used in many systems, such as the text-based utilities in the UNIX operating system. Whenever different data sets need to be manipulated in different ways, you should consider using the pipe and filter architecture.

Compilers: They perform language transformation. Input is in language e.g. Java and output is in machine language. In order to do that the input goes through various stages inside the compiler — these stages form the pipeline. The most commonly used division consists of 3 stages: front-end, middle-end, and back-end. The front-end is responsible for parsing the input language and performing syntax and semantic and then transforms it into an intermediate language. The middle-end takes the intermediate representation and usually performs several optimization steps on it, the resulting transformed program in is passed to the back-end which transforms it into language B. Each level consists of several steps as well, and everything together forms the pipeline of the compiler.
UNIX Shell: The Pipeline is one of the defining features of the UNIX shell, and obviously, the same goes for Linux, MacOS, and any other Unix-based or inspired systems. In a nutshell, it allows you to tie the output of one program to the input of another. The benefit it brings is that you don’t have to save the results of one program before you can start processing it with another. The long-term and even more important benefit is that it encourages programs to be small and simple. There is no need for every program to include a word-counter if they can all be piped into wc. Similarly, no program needs to offer its own built-in pattern matching facilities, as it can be piped into grep. In the provided example, the input.txt is read and the output is then provided to grep as input which searches for the pattern “text” and then passes the results to sort, which sorts the results and outputs into the file, output.txt.

cat input.txt | grep "text" | sort > output.txt

input.txt ➜ grep ➜ sort ➜ output.txt

ATM system

Advantages

Easy and simple for composition and evolution
Intuitive and easy to understand
The filters are discrete: reusability and low coupling between components (modifiability)
Concurrency support

Disadvantages

Each filter must analyze its data
Difficult to share global data
Problems with reuse - e.g. functional transformations with incompatible data
The data transmission format must be agreed
Does not provide a way for filters to interact together to solve a problem