Architecture Representation

1
Architecture Representation
2
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

3
Outline (Contd)

• 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

4
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

5
A Model for Representing a Software Architecture
(Contd)

• 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

6
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

7
Foundations of Software Architecture (Contd)

• 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.

8
Fundamental Software Design Views (Contd)

• 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)

9
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.

10
Architecture Description Languages (Contd)

• 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

11
Common Component Interactions

• Procedure call
• Data flow
• Implicit invocation
• Message passing
• Shared data
• Instantiation

12
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

13
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

14
Six Classes of Properties that Should
Characterize an ADL

• Composition
• Abstraction
• Reusability
• Configuration
• Heterogeneity
• Architectural Analysis

15
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.

16
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.

17
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.

18
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.

19
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.

20
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.

21
First-Class Connectors

• Connectors should be considered equal to
  components.
• Connectors often embody the nonfunctional quality
  attributes and bring form to the architecture.

22
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.

23
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.

24
An ADL Example C2 SADL (Contd)

• 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.

25
An ADL Example C2 SADL (Contd)

• 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

26
Applying ADLs

• 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.

27
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.

28
Summary (Contd)

• 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.