Object-Oriented Analysis and Design

Lecture 5: Architectural Analysis

Objectives: Architectural Analysis
 Explain the purpose of Architectural Analysis
and where it is performed in the lifecycle.
 Describe a representative architectural pattern
and set of analysis mechanisms, and how they
affect the architecture.
 Describe the rationale and considerations that
support the architectural decisions.
 Show how to read and interpret the results of
Architectural Analysis:
 Architectural layers and their relationships
 Key abstractions
 Analysis mechanisms

Object Oriented Analysis and Design 2

Architectural Analysis in Context
[Early
Elaboration [Inception
Iteration] Iteration (Optional)]

Architecture
Analysis Define a Candidate Perform
Architect
Architecture Architectural
Synthesis

Analyze Behavior

(Optional)
Refine the
Architecture

Define Design the

Components Database

Object Oriented Analysis and Design 3

Architectural Analysis Overview

Supplementary Glossary Software Reference Vision

Specification Architecture Doc Architecture Document

Architectural
Analysis

Project-Specific Design Model

Guidelines

Use-Case Model Deployment Model

Object Oriented Analysis and Design 4

Architectural Analysis Steps
 Key Concepts
 Define the High-Level Organization of
Subsystems
 Identify Analysis mechanisms
 Identify Key Abstractions
 Create Use-Case Realizations
 Checkpoints

Object Oriented Analysis and Design 5

Review: What Is Architecture: The “4+1 View” Model

Logical View Implementation View

End-user
Analysts/Designers Programmers
Functionality
Structure Software management
Use-Case View

Process View Deployment View

System integrators System engineering
Performance System topology
Scalability Delivery, installation
Throughput communication

Object Oriented Analysis and Design 6

Review: What Is a Package?
 A package is a general-purpose mechanism
for organizing elements into groups.
 It is a model element that can contain other
model elements.

University
Artifacts

 A package can be used

 To organize the model under development.
 As a unit of configuration management.

Object Oriented Analysis and Design 7

Package Relationships: Dependency
 Packages can be related to one another using a
dependency relationship.
Dependency relationship
Client Package Supplier
Package

 Dependency Implications
• Changes to the Supplier package may affect the
Client package.
• The Client package cannot be reused independently
because it depends on the Supplier package.

Object Oriented Analysis and Design 8

Avoiding Circular Dependencies

A
A

Hierarchy
B should be B
acyclic
A
C
B

A'
C
Circular dependencies make it impossible
to reuse one package without the other.
Object Oriented Analysis and Design 9
Architectural Analysis Steps
 Key Concepts
 Define the High-Level Organization of
Subsystems
 Identify Analysis mechanisms
 Identify Key Abstractions
 Create Use-Case Realizations
 Checkpoints

Object Oriented Analysis and Design 10

Patterns and Frameworks
 Pattern
 Provides a common solution to a common problem
in a context
 Analysis/Design pattern
 Provides a solution to a narrowly-scoped technical
problem
 Provides a fragment of a solution, or a piece of the
puzzle
 Framework
 Defines the general approach to solving the
problem
 Provides a skeletal solution, whose
details may be Analysis/Design patterns
Object Oriented Analysis and Design 11
What Is a Design Pattern?
 A design pattern is a solution to a common
design problem.
 Describes a common design problem
 Describes the solution to the problem
 Discusses the results and trade-offs of applying the
pattern
 Design patterns provide the capability to reuse
successful designs.
Template
Parameters

Pattern Name

Parameterized Structural Aspect Behavioral Aspect

Collaboration
Object Oriented Analysis and Design 12
What Is an Architectural Pattern?
 An architectural pattern expresses a fundamental
structural organization schema for software
systems. It provides a set of predefined
subsystems, specifies their responsibilities, and
includes rules and guidelines for organizing the
relationships between them – Buschman et al,
“Pattern-Oriented Software Architecture — A System of
Patterns”
 Layers
 Model-view-controller (M-V-C)
 Pipes and filters
 Blackboard

Object Oriented Analysis and Design 13

Typical Layering Approach
Specific
functionality

Distinct application subsystems that make

up an application — contains the value
Application Subsystems adding software developed by the
organization.

Business specific — contains a number of

Business-Specific reusable subsystems specific to the type of
business.

Middleware — offers subsystems for utility

classes and platform-independent services
Middleware for distributed object computing in
heterogeneous environments and so on.

System software — contains the software

for the actual infrastructure such as
System Software operating systems, interfaces to specific
hardware, device drivers, and so on.

General
functionality

Object Oriented Analysis and Design 14

Architectural Pattern: Layers
Equipment and
customer-specific 5
code
Application

Processes and other

application code 4

Major abstractions,
classes, etc. 3
Application
Framework
Mechanisms, 2
services
Infrastructure

H/W specific code, O/S

specific code, general- 1
purpose code (for
example, ORB, MQS)

Object Oriented Analysis and Design 15

Layering Considerations
 Level of abstraction
 Group elements at the same level of abstraction
 Separation of concerns
 Group like things together
 Separate disparate things
 Application vs. domain model elements
 Resiliency
 Loose coupling
 Concentrate on encapsulating change
 User interface, business rules, and retained data tend
to have a high potential for change

Object Oriented Analysis and Design 16

Modeling Architectural Layers
 Architectural layers can be modeled using
stereotyped packages.
 <<layer>> stereotype

<<layer>>
Package Name

Object Oriented Analysis and Design 17

Example: High-Level Organization of the Model

<<layer>>
Application

<<layer>>
Business Services

Object Oriented Analysis and Design 18

Architectural Analysis Steps
 Key Concepts
 Define the High-Level Organization of
Subsystems
 Identify Analysis mechanisms
 Identify Key Abstractions
 Create Use-Case Realizations
 Checkpoints

Object Oriented Analysis and Design 19

What Are Architectural Mechanisms?
Required Implementation
Functionality Environment
“realized by client
classes using” “constrained by”
COTS Products
Mechanisms Databases
IPC Technology
Supplementary
etc.
Specification

“responsible for”

Use-Case Model
Architect

Object Oriented Analysis and Design 20

Architectural Mechanisms: Three Categories
 Architectural Mechanism Categories
 Analysis mechanisms (conceptual)
 Design mechanisms (concrete)
 Implementation mechanisms (actual)

Object Oriented Analysis and Design 21

Why Use Analysis Mechanisms?
Oh no! I found a group of classes that
has persistent data. How am I
supposed to design these things if I
don’t even know what database we are
going to be using?

That is why we have a persistence

analysis mechanism. We don’t
know enough yet, so we can
bookmark it and come back to it
later.

Analysis mechanisms are used during analysis to reduce the complexity of

analysis and to improve its consistency by providing designers with a
shorthand representation for complex behavior.

Object Oriented Analysis and Design 22

Sample Analysis Mechanisms
 Persistency
 Communication (IPC and RPC)
 Message routing
 Distribution
 Transaction management
 Process control and synchronization (resource
contention)
 Information exchange, format conversion
 Security
 Error detection / handling / reporting
 Redundancy
 Legacy Interface

Object Oriented Analysis and Design 23

Examples of Analysis Mechanism Characteristics
 Persistency mechanism
 Granularity
 Volume
 Duration
 Access mechanism
 Access frequency (creation/deletion, update, read)
 Reliability
 Inter-process Communication mechanism
 Latency
 Synchronicity
 Message size
 Protocol

Object Oriented Analysis and Design 24

Example of Analysis Mechanism Characteristics (cont.)

 Legacy interface mechanism

 Latency
 Duration
 Access mechanism
 Access frequency
 Security mechanism
 Data granularity
 User granularity
 Security rules
 Privilege types
 Others
Object Oriented Analysis and Design 25
Describing Analysis Mechanisms
Analysis
 Collect all analysis Classes Mechanisms

mechanisms in a list Flight

 Draw a map of classes Aircraft

Persistency

to analysis mechanisms
 Identify characteristics Mission Communication

of analysis mechanisms Schedule

 Model using Parsing

collaborations Route

Authentication
Load

Object Oriented Analysis and Design 26

Example: Course Registration Analysis Mechanisms
 Persistence
 Distribution
 Security
 Legacy Interface

Object Oriented Analysis and Design 27

Architectural Analysis Steps
 Key Concepts
 Define the High-Level Organization of
Subsystems
 Identify Analysis mechanisms
 Identify Key Abstractions
 Create Use-Case Realizations
 Checkpoints

Object Oriented Analysis and Design 28

What Are Key Abstractions?
 A key abstraction is a concept, normally
uncovered in Requirements, that the
system must be able to handle
 Sources for key abstractions
 Domain knowledge
 Requirements
 Glossary
 Domain Model, or the Business
Model (if one exists)

Object Oriented Analysis and Design 29

Defining Key Abstractions
 Define analysis class relationships
 Model analysis classes and relationships
on class diagrams
 Include brief description of
analysis class

 Map analysis classes to

necessary analysis
mechanisms

Object Oriented Analysis and Design 30

Example: Key Abstractions

Professor Student

Schedule

CourseCatalog CourseOffering Course

Object Oriented Analysis and Design 31

Architectural Analysis Steps
 Key Concepts
 Define the High-Level Organization of
Subsystems
 Identify Analysis mechanisms
 Identify Key Abstractions
 Create Use-Case Realizations
 Checkpoints

Object Oriented Analysis and Design 32

Review: What is a Use-Case Realization?
Use-Case Model Design Model

Use Case Use-Case Realization

Collaboration Diagrams
Sequence Diagrams

Use Case
Class Diagrams

Object Oriented Analysis and Design 33

The Value of Use-Case Realizations
 Provides traceability from Analysis and Design
back to Requirements
 The Architect creates the Use-Case Realization

Requirements Analysis & Design

Use Case Use-Case

Realization

Object Oriented Analysis and Design 34

Architectural Analysis Steps
 Key Concepts
 Define the High-Level Organization of
Subsystems
 Identify Analysis mechanisms
 Identify Key Abstractions
 Create Use-Case Realizations
 Checkpoints

Object Oriented Analysis and Design 35

Checkpoints
 General
 Is the package partitioning and
layering done in a logically
consistent way?
 Have the necessary analysis
mechanisms been identified?
 Packages
 Have we provided a comprehensive
picture of the services of the
packages in upper-level layers?

(continued)
Object Oriented Analysis and Design 36
Checkpoints (cont.)
 Classes
 Have the key entity classes and
their relationships been identified
and accurately modeled?
 Does the name of each class clearly
reflect the role it plays?
 Are the key abstractions/classes
and their relationships consistent
with the Business Model, Domain
Model, Requirements, Glossary,
etc.?

Object Oriented Analysis and Design 37

Review: Architectural Analysis
 What is the purpose of Architectural Analysis?
 What is a package?
 What are analysis mechanisms? Give examples.
 What key abstractions are identified during
Architectural Analysis? Why are they identified
here?
 What is a layered architecture? Give examples of
typical layers.

Object Oriented Analysis and Design 38

Exercise: Architectural Analysis
 Given the following:
 Some results from the Requirements
discipline:
• Problem statement
• Use-Case Model main diagram
• Glossary
 Some architectural decisions:
• (textually) The upper-level
architectural layers and their
dependencies
(continued)
Object Oriented Analysis and Design 39
Exercise: Architectural Analysis (cont.)
 Identify the following:
 The key abstractions

(continued)
Object Oriented Analysis and Design 40
Exercise: Architectural Analysis (cont.)
 Produce the following:
 Class diagram containing the key
abstractions
 Class diagram containing the
upper-level architectural layers
and their dependencies

Object Oriented Analysis and Design 41

Exercise: Review
 Compare your key abstractions
with the rest of the class
 Have the key concepts been
identified?
 Does the name of each class
reflect the role it plays?
 Compare your class diagram
showing the upper-level layers
 Do the package relationships
support the Payroll System
architecture?

Object Oriented Analysis and Design 42