architecture representation. outline goals of architecture representation foundations of software...

28
Architecture Representation

Upload: jessie-hebbard

Post on 22-Dec-2015

234 views

Category:

Documents


2 download

TRANSCRIPT

Page 1: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Architecture Representation

Page 2: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Outline

Goals of Architecture Representation Foundations of Software Architecture

Representation Architecture Description Languages

Design language elements First-class connectors Modules and Components Applying ADLs

Summary

Page 3: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Outline (Cont’d)

Modeling the problem and the solution domains Problem domain models Solution domain models

Views Objectives and purpose models Behavioral/functional models Information/data models Models of form Nonfunctional/performance models

Summary

Page 4: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

A Model for Representing a Software Architecture Goals of architecture representation – a

representation of a system that can be used to: Design a system Analyze a design Generate a system

Foundations of software architecture representation – the elements for describing an architecture are: Components Connectors Architectural constraints

Page 5: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

A Model for Representing a Software Architecture (Cont’d) Architectural description languages – ADLs are

(machine readable) design languages used to describe a system that possess design language properties like: Composition Abstraction Reusability Configuration Heterogeneity Analysis

Page 6: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Foundations of Software Architecture Three types of constructs are

necessary in representing software architectures: Elements Form Rationale

Their elements are classified as: Data Processing Connecting

Page 7: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Foundations of Software Architecture (Cont’d) The architectural form is composed of

weighted (by importance or necessity) properties and relationships.

Properties may be used to define constraints. Relationships may be used to show how

different architectural elements interact. Rationales capture the motivation behind

various decisions; they are inferences that can be structured as an argument with the design decision being the conclusion.

Page 8: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Fundamental Software Design Views (Cont’d)

Architectural styles can be sequential or parallel In the sequential style the connecting

elements are procedure calls and parameters

In the parallel style the connecting element is a shared representation of the data (a repositiory)

Page 9: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Architecture Description Languages Programming language structures are

inadequate for describing architectural elements.

Furthermore, they provide no way to model a strict separation of concerns between architectural-level design issues and detail design issues.

Languages in general serve the purpose of describing complex relationships among primitive elements and element combinations.

Page 10: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Architecture Description Languages (Cont’d) Having identified semantic constructs it makes

sense to define a language around them. Common architectural description elements

include: (Pure) computation (processing elements) – simple

input/output relations with no retained state Memory (data elements) – shared collections of

persistent structured data Manager – manage state and closely related

operations Controller – governs the sequence of operations Link – transmit information between elements

Page 11: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Common Component Interactions

Procedure call Data flow Implicit invocation Message passing Shared data Instantiation

Page 12: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Design Language Elements -- Albin Components – the primitive semantic elements Operators – functions that combine

components Abstraction rules – allow for the definition of

named expressions of components and operators

Closure rules – determines which abstractions can be added to the classes of primitive components and operators

Specification – associates semantics to syntactic forms

Page 13: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Design Language Elements – Shaw and Garlan Components – the modules that compose the

architectural level of design Operators – the inter-component connection

mechanisms Patterns – design templates that solve a

particular set of problems (a framework) Closure – defines the conditions under which a

particular assembly of components and operators may also be used as an atomic component

Specification – associates semantics such as functionality and other quality attributes to the syntactic forms

Page 14: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Six Classes of Properties that Should Characterize an ADL

Composition Abstraction Reusability Configuration Heterogeneity Architectural Analysis

Page 15: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Composition

An ADL should allow for the description of a system as a composition of components and connectors.

It must support the ability to split a system or module into two modules

It must support the ability to synthesize or combine modules to create new forms.

These splitting or synthesis operations should be independent of implementation design decisions (choice of algorithms, data structures, connecting technology, etc.)

A composition of elements must be allowed to be viewed as a single component.

It must be possible to operate on the individual components of the composition.

Page 16: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Abstraction

An ADL should allow a designer to focus on high-level concerns without having to think in terms of programming level constructs.

Architectural abstractions are patterns of programming language constructs.

An architect can think in terms of components and connectors focusing on the architectural concerns of modifiability, reliability, performance, etc. without having to map them to specific programming language elements.

Page 17: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Reusability

It should be possible to modularize a specification written in a particular ADL so that the components can be used in other systems.

These specifications are reusable patterns of components.

For example, a certain client-server pattern might identify a database server component with a particular database table structure (a reusable data model).

Each physical database implementation might look different but each would have the same core data and enforce the same semantic rules.

Page 18: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Configuration

It should be possible with an ADL to describe a composite structure separately from its elements so that the composition can be reasoned about as an atomic element.

It should support the dynamic reconfiguration of a system in terms of restructuring compositions without knowing their internal structure.

For example, in a client/server system, an indefinite number of clients may be executing at any time.

Page 19: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Heterogeneity

This is the ability to mix architectural styles within a single architectural specification.

At one level, the architecture may exhibit a particular pattern of compositions, but the structure of each composition may follow a different pattern.

An ADL should allow different compositions to be compiled to different languages.

Page 20: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Architecture Analysis

An ADL should support the ability to analyze an architecture.

Analysis of architecture includes both automated and non automated reasoning about quality attributes of a system.

ADL research aims to automate this analysis by providing machine-readable specifications of specific quality attribute requirements and then checking to see if the architecture specification conforms to it.

Page 21: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

First-Class Connectors

Connectors should be considered equal to components.

Connectors often embody the nonfunctional quality attributes and bring form to the architecture.

Page 22: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Modules and Components

“A module is a unit whose structural elements are powerfully connected among themselves and relatively weakly connected to elements of other units. Clearly there degrees of connection; thus gradations of modularity.” – Baldwin

Programming languages are insufficient for representing architectural level designs because they lack explicit connecting elements.

Connecting elements are just as important from the architectural level of design as processing and data elements.

The ability to abstract the implementation of a connecting element within an architecture specification is what makes an ADL so powerful.

Page 23: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

An ADL Example – C2 SADL

The C2 Software Architecture Description Language is intended for designing a flexible, extensible component- and message- based system that has a graphical user interface.

A C2-based system is structured as a hierarchy of concurrent components that communicate via connectors, which are message-routing mechanisms.

A component can have at most two connectors – a top connector and a bottom connector, which attach to components either up one level in the hierarchy or down one level.

The top connector of one component is coupled with the bottom connectors of other components, and vice versa.

Page 24: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

An ADL Example – C2 SADL (Cont’d) There is no limit to the number of connectors

that ma be coupled with a single connector. A C2 component is only aware of the

components above it, not those below. Requests go up and notifications go down. There is one component at the top. The C2 architectural style relies on a

programming language neutral event mechanism, such as a message queue.

Page 25: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

An ADL Example – C2 SADL (Cont’d) C2 SADL is composed of three parts:

Interface Definition Notation (IDN) Supports textual specification of C2 component

interfaces Consists of specifications for parameters,

methods, behavior, and context Architecture Description Notation (ADN)

Supports textual specification of a C2 architecture Architecture Construction Notation (ACN)

Supports textural specification of architecture changes

Page 26: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Applying ADL’s

ADLs are not commonly used. Most are experimental. Understanding the problems that ADLs

attempt to solve, can help an architect to think about the solution to a particular problem.

Understanding ADLs helps the architect to focus on the nature of connections between components.

Page 27: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Summary

The component level of design allows us to reason about the properties of the system without first constructing the entire system.

The fundamental language of specifying architecture design is composed of elements, form, and rationale.

Elements are processing, data, and connecting Form is composed of weighted properties and

relationships. Rationales capture the reasons why certain

design decisions were made.

Page 28: Architecture Representation. Outline  Goals of Architecture Representation  Foundations of Software Architecture Representation  Architecture Description

Summary (Cont’d)

Architecture Description Languages (ADLs) are high-level languages for describing the component view of a software system.

ADLs have not been applied much in practice. UML is often used as an ADL even though it is

inadequate. The dependency (design) structure matrix is still

one of the most powerful representation tools.