Design Patterns and Architectures

Design patterns

- A design pattern is a way of reusing abstract knowledge about a problem and its solution. - A pattern is a description of the problem and the essence of its solution. - It should be sufficiently abstract to be reused in different settings. - Pattern descriptions usually make use of object-oriented characteristics such as inheritance and polymorphism.

key points

- A software architecture is a description of how a software system is organized. - Architectural design decisions include decisions on the type of application, the distribution of the system, the architectural styles to be used. - Architectures may be documented from several different perspectives or views such as a conceptual view, a logical view, a process view, and a development view. - Architectural patterns are a means of reusing knowledge about generic system architectures. They describe the architecture, explain when it may be used and describe its advantages and disadvantages.

Architectural Design

- Architectural design is concerned with understanding how a software system should be organized and designing the overall structure of that system. - Architectural design is the critical link between design and requirements engineering, as it identifies the main structural components in a system and the relationships between them.

client-server architecture

- Distributed system model which shows how data and processing is distributed across a range of components. Can be implemented on a single computer. - Set of stand-alone servers which provide specific services such as printing, data management, etc. - Set of clients which call on these services. - Network which allows clients to access servers

Architectural patterns

- Patterns are a means of representing, sharing and reusing knowledge. - An architectural pattern is a stylized description of good design practice, which has been tried and tested in different environments. - Patterns should include information about when they are and when the are not useful. - Patterns may be represented using tabular and graphical descriptions.

Layered architecture

- Used to model the interfacing of sub-systems. - Organizes the system into a set of layers (or abstract machines) each of which provide a set of services. - Supports the incremental development of sub-systems in different layers. When a layer interface changes, only the adjacent layer is affected.

Pattern elements

- name: a meaningful pattern identifier - problem description - solution description: Not a concrete design but a template for a design solution that can be instantiated in different ways - consequences: The results and trade-offs of applying the pattern

4+1 View Model of Software Architecture

1. A logical view, which shows the key abstractions in the system as objects or object classes. 2. A process view, which shows how, at run-time, the system is composed of interacting processes. 3. A development view, which shows how the software is decomposed for development. 4. A physical view, which shows the system hardware and how software components are distributed across the processors in the system. 5. Related using use cases or scenarios (+1)

Pipe and filter architecture

Functional transformations process their inputs to produce outputs. May be referred to as a pipe and filter model (as in UNIX shell). Variants of this approach are very common. When transformations are sequential, this is a batch sequential model which is extensively used in data processing systems. Not really suitable for interactive systems.

Repository architecture

Sub-systems must exchange data. This may be done in two ways: ◦ Shared data is held in a central database or repository and may be accessed by all sub-systems; ◦ Each sub-system maintains its own database and passes data explicitly to other sub-systems. When large amounts of data are to be shared, the repository model of sharing is most commonly used a this is an efficient data sharing mechanism.

Design problems and patterns

To use patterns in your design, you need to recognize that any design problem you are facing may have an associated pattern that can be applied. ◦ Tell several objects that the state of some other object has changed (Observer pattern). ◦ Tidy up the interfaces to a number of related objects that have often been developed incrementally (Façade pattern). ◦ Provide a standard way of accessing the elements in a collection, irrespective of how that collection is implemented (Iterator pattern). ◦ Allow for the possibility of extending the functionality of an existing class at run-time (Decorator pattern).

Architectural views

What views or perspectives are useful when designing and documenting a system's architecture? What notations should be used for describing architectural models? Each architectural model only shows one view or perspective of the system.

Model-View-Controller (MVC)

see notes