Architecture design in software engineering

Mishra
Course Instructor

software architecture of a program or computing system is
the structure or structures of the system which comprise
– The software components
– The externally visible properties of those components
– The relationships among the components
• Software architectural design represents the structure of the
data and program components that are required to build a
computer-based system
• An architectural design model is transferable
– It can be applied to the design of other systems
– It represents a set of abstractions that enable software engineers to
describe architecture in predictable ways

architecture is not the operational software. RRaatthheerr,, iitt iiss aa
rreepprreesseennttaattiioonn tthhaatt eennaabblleess aa ssooffttwwaarree eennggiinneeeerr ttoo::
((11)) analyze the effectiveness of the design iinn mmeeeettiinngg iittss ssttaatteedd
rreeqquuiirreemmeennttss,,
((22)) consider architectural alternatives aatt aa ssttaaggee wwhheenn mmaakkiinngg
ddeessiiggnn cchhaannggeess iiss ssttiillll rreellaattiivveellyy eeaassyy,, aanndd
((33)) reduce the risks aassssoocciiaatteedd wwiitthh tthhee ccoonnssttrruuccttiioonn ooff tthhee
ssooffttwwaarree..

Important?
• Representations of software architecture are an enabler
for communication between all parties (stakeholders)
interested in the development of a computer-based system.
• The architecture highlights early design decisions that will
have a profound impact on all software engineering work
that follows and, as important, on the ultimate success of
the system as an operational entity.
• Architecture “constitutes a relatively small, intellectually
graspable mode of how the system is structured and how its
components work together”

The IEEE Computer Society has proposed IEEE-Std-1471-2000,
Recommended Practice for Architectural Description of Software-
Intensive System, [IEE00]
– to establish a conceptual framework and vocabulary for use during the
design of software architecture,
– to provide detailed guidelines for representing an architectural description,
and
– to encourage sound architectural design practices.
• The IEEE Standard defines an architectural description (AD) as a “a
collection of products to document an architecture.”
– The description itself is represented using multiple views, where each view
is “a representation of a whole system from the perspective of a related set
of [stakeholder] concerns.”

• Basic Steps
– Creation of the data design
– Derivation of one or more representations of the architectural
structure of the system
– Analysis of alternative architectural styles to choose the one best
suited to customer requirements and quality attributes
– Elaboration of the architecture based on the selected architectural
style
• A database designer creates the data architecture for a system
to represent the data components
• A system architect selects an appropriate architectural style
derived during system engineering and software requirements
analysis

Components
• A software architecture enables a software engineer to
– Analyze the effectiveness of the design in meeting its stated
requirements
– Consider architectural alternatives at a stage when making
design changes is still relatively easy
– Reduce the risks associated with the construction of the
software
• Focus is placed on the software component
– A program module
– An object-oriented class
– A database
– Middleware

Design
• Data design translates data objects defined as part of the
analysis model into
– Data structures at the software component level
– A possible database architecture at the application level
• It focuses on the representation of data structures that
are directly accessed by one or more software components
• The challenge is to store and retrieve the data in such way
that useful information can be extracted from the data
environment
• “Data quality is the difference between a data warehouse
and a data garbage dump”

• The systematic analysis principles that are applied to function and
behavior should also be applied to data
• All data structures and the operations to be performed on each one
should be identified
• A mechanism for defining the content of each data object should be
established and used to define both data and the operations applied
to it
• Low-level data design decisions should be deferred until late in the
design process
• The representation of a data structure should be known only to those
modules that must make direct use of the data contained within the
structure
• A library of useful data structures and the operations that may be
applied to them should be developed
• A software programming language should support the specification
and realization of abstract data types

13
of American Homes

style describes a system category tthhaatt eennccoommppaasssseess::
((11)) aa set of components ((ee..gg..,, aa ddaattaabbaassee,, ccoommppuuttaattiioonnaall mmoodduulleess)) tthhaatt ppeerrffoorrmm aa
ffuunnccttiioonn rreeqquuiirreedd bbyy aa ssyysstteemm,,
((22)) aa set of connectors tthhaatt eennaabbllee ““ccoommmmuunniiccaattiioonn,, ccoooorrddiinnaattiioonn aanndd ccooooppeerraattiioonn””
aammoonngg ccoommppoonneennttss,,
((33)) constraints tthhaatt ddeeffiinnee hhooww ccoommppoonneennttss ccaann bbee iinntteeggrraatteedd ttoo ffoorrmm tthhee ssyysstteemm,,
((44)) semantic models tthhaatt eennaabbllee aa ddeessiiggnneerr ttoo uunnddeerrssttaanndd tthhee oovveerraallll pprrooppeerrttiieess ooff
aa ssyysstteemm bbyy aannaallyyzziinngg tthhee kknnoowwnn pprrooppeerrttiieess ooff iittss ccoonnssttiittuueenntt ppaarrttss..
• Data-centered architectures
• Data flow architectures
• Call and return architectures
• Object-oriented architectures
• Layered architectures

• The software that is built for computer-based systems
exhibit one of many architectural styles
• Each style describes a system category that encompasses
– A set of component types that perform a function required by
the system
– A set of connectors (subroutine call, remote procedure call,
data stream, socket) that enable communication, coordination,
and cooperation among components
– Semantic constraints that define how components can be
integrated to form the system
– A topological layout of the components indicating their runtime
interrelationships

Architectural
16
Styles Independent Components
Communicating
Processes
Event Systems
Client/Server Peer-to-Peer Implicit
Invocation
Explicit
Invocation
Data Flow
Batch Sequential Pipe and
Filter
Virtual Machine
Interpreter Rule-Based
System
Data-Centered
Repository Blackboard
Call and Return
Main Program
and Subroutine
Object
Layered Oriented
Remote Procedure Call

Validate Sort Update Report

• Has the goal of modifiability
• Characterized by viewing the system as a series of transformations on
successive pieces of input data
• Data enters the system and then flows through the components one at
a time until they are assigned to output or a data store
• Batch sequential style
– The processing steps are independent components
– Each step runs to completion before the next step begins
• Pipe-and-filter style
– Emphasizes the incremental transformation of data by successive
components
– The filters incrementally transform the data (entering and exiting via
streams)
– The filters use little contextual information and retain no state between
instantiations
– The pipes are stateless and simply exist to move data between filters

(continued)
• Advantages
– Has a simplistic design in the limited ways in which the
components interact with the environment
– Consists of no more and no less than the construction of its parts
– Simplifies reuse and maintenance
– Is easily made into a parallel or distributed execution in order to
enhance system performance
• Disadvantages
– Implicitly encourages a batch mentality so interactive applications
are difficult to create in this style
– Ordering of filters can be difficult to maintain so the filters
cannot cooperatively interact to solve a problem
– Exhibits poor performance
• Filters typically force the least common denominator of data
representation (usually ASCII stream)
• Filter may need unlimited buffers if they cannot start producing
output until they receive all of the input
• Each filter operates as a separate process or procedure call, thus
incurring overhead in set-up and take-down time

(continued)
• Use this style when it makes sense to view your system as one
that produces a well-defined easily identified output
– The output should be a direct result of sequentially transforming
a well-defined easily identified input in a time-independent
fashion

Has the goal of modifiability and scalability
• Has been the dominant architecture since the start of software
development
• Main program and subroutine style
– Decomposes a program hierarchically into small pieces (i.e., modules)
– Typically has a single thread of control that travels through various
components in the hierarchy
• Remote procedure call style
– Consists of main program and subroutine style of system that is
decomposed into parts that are resident on computers connected via
a network
– Strives to increase performance by distributing the computations
and taking advantage of multiple processors
– Incurs a finite communication time between subroutine call and
response

• Object-oriented or abstract data type system
– Emphasizes the bundling of data and how to manipulate and access data
– Keeps the internal data representation hidden and allows access to the
object only through provided operations
– Permits inheritance and polymorphism
• Layered system
– Assigns components to layers in order to control inter-component
interaction
– Only allows a layer to communicate with its immediate neighbor
– Assigns core functionality such as hardware interfacing or system kernel
operations to the lowest layer
– Builds each successive layer on its predecessor, hiding the lower layer
and providing services for the upper layer
– Is compromised by layer bridging that skips one or more layers to
improve runtime performance
• Use this style when the order of computation is fixed, when
interfaces are specific, and when components can make no useful
progress while awaiting the results of request to other components

Main module
Subroutine A Subroutine B
Subroutine A-1 Subroutine A-2
Application layer Class V Class W
Transport layer
Network layer
Data layer
Physical layer
Class X
Class Z
Class Y

Architecture

Concurrency—applications must handle multiple tasks in a manner that simulates
parallelism
– operating system process management pattern
– task scheduler pattern
• Persistence—Data persists if it survives past the execution of the process that
created it. Two patterns are common:
– a database management system pattern that applies the storage and retrieval
capability of a DBMS to the application architecture
– an application level persistence pattern that builds persistence features into the
application architecture
• Distribution— the manner in which systems or components within systems
communicate with one another in a distributed environment
– A broker acts as a ‘middle-man’ between the client component and a server component.

The software must be placed into context
– the design should define the external entities (other systems,
devices, people) that the software interacts with and the nature of
the interaction
• A set of architectural archetypes should be identified
– An archetype is an abstraction (similar to a class) that represents
one element of system behavior
• The designer specifies the structure of the system by
defining and refining software components that implement
each archetype

Product
Internet-based
target system:
Security Function
uses
system
surveillance
function
homeowner uses peers
sensors
control
panel
uses
sensors

communicates with
Detector Indicator
Figure 10.7 UML relationships for SafeHome security function archetypes
(adapted from [BOS00])

Execut ive
Ext ernal
Communicat ion
Management
GUI Int ernet
Int erface
Funct ion
select ion
Securit y Surveillance Home
management
Cont rol
panel
processing
det ect or
management
alarm
processing

sensor
sseennssoor sensor
r
sseennssoor sseennssoor r r Ext ernal
Communicat ion
Management
GUI Internet
Interface
Security
Cont rol
panel
processing
det ect or
management
alarm
processing
Key pad
processing
CP display
funct ions
scheduler
sseennssoor r sseennssoor r
phone
communicat ion
alarm
SafeHome
Executive

11.. CCoolllleecctt sscceennaarriiooss..
22.. EElliicciitt rreeqquuiirreemmeennttss,, ccoonnssttrraaiinnttss,, aanndd eennvviirroonnmmeenntt ddeessccrriippttiioonn..
3.. DDeessccrriibbee tthhee aarrcchhiitteeccttuurraall ssttyylleess//ppaatttteerrnnss tthhaatt hhaavvee bbeeeenn cchhoosseenn
ttoo aaddddrreessss tthhee sscceennaarriiooss aanndd rreeqquuiirreemmeennttss::
•• mmoodduullee vviieeww
•• pprroocceessss vviieeww
•• ddaattaa ffllooww vviieeww
44.. EEvvaalluuaattee qquuaalliittyy aattttrriibbuutteess bbyy ccoonnssiiddeerreedd eeaacchh aattttrriibbuuttee iinn
iissoollaattiioonn..
55.. IIddeennttiiffyy tthhee sseennssiittiivviittyy ooff qquuaalliittyy aattttrriibbuutteess ttoo vvaarriioouuss
aarrcchhiitteeccttuurraall aattttrriibbuutteess ffoorr aa ssppeecciiffiicc aarrcchhiitteeccttuurraall ssttyyllee..
66.. CCrriittiiqquuee ccaannddiiddaattee aarrcchhiitteeccttuurreess ((ddeevveellooppeedd iinn sstteepp 3)) uussiinngg tthhee
sseennssiittiivviittyy aannaallyyssiiss ccoonndduucctteedd iinn sstteepp 55..

the overall complexity of a proposed architecture is
assessed by considering the dependencies between
components within the architecture [Zha98]
– Sharing dependencies represent dependence relationships among
consumers who use the same resource or producers who produce for
the same consumers.
– Flow dependencies represent dependence relationships between
producers and consumers of resources.
– Constrained dependencies represent constraints on the relative flow
of control among a set of activities.

description language (ADL) provides
a semantics and syntax for describing a software
architecture
• Provide the designer with the ability to:
– decompose architectural components
– compose individual components into larger architectural
blocks and
– represent interfaces (connection mechanisms) between
components.

Method
customer requirements
“four bedrooms, three baths,
lots of glass …”
architectural design

PPrrooggrraamm
AArrcchhiitteeccttuurree

• “horizontal” and “vertical”
partitioning are required

define separate branches of the module
hierarchy for each major function
• use control modules to coordinate
communication between functions
ffuunnccttiioonn 11 ffuunnccttiioonn 33
ffuunnccttiioonn 22

• design so that decision making and work
are stratified
• decision making modules should reside
at the top of the architecture
decision-makers
workers

• results in software that is easier to test
• leads to software that is easier to maintain
• results in propagation of fewer side effects
• results in software that is easier to extend

objective: to derive a program architecture that is
partitioned
• approach:
– a DFD is mapped into a program architecture
– the PSPEC and STD are used to indicate the content of
each module
• notation: structure chart

flow
Transaction
flow
This edition of
SEPA does not
cover transaction
mapping. For a
detailed
discussion see the
SEPA website

isolate incoming aanndd oouuttggooiinngg ffllooww
bboouunnddaarriieess;; ffoorr ttrraannssaaccttiioonn fflloowwss,, iissoollaattee
tthhee ttrraannssaaccttiioonn cceenntteerr
wwoorrkkiinngg ffrroomm tthhee bboouunnddaarryy oouuttwwaarrdd,, mmaapp
DDFFDD ttrraannssffoorrmmss iinnttoo ccoorrrreessppoonnddiinngg mmoodduulleess
aadddd ccoonnttrrooll mmoodduulleess aass rreeqquuiirreedd
rreeffiinnee tthhee rreessuullttaanntt pprrooggrraamm ssttrruuccttuurree
uussiinngg eeffffeeccttiivvee mmoodduullaarriittyy ccoonncceeppttss

• Isolate the transform center by specifying incoming and
outgoing flow boundaries
• Perform “first-level factoring.”
– The program architecture derived using this mapping results in a
top-down distribution of control.
– Factoring leads to a program structure in which top-level
components perform decision-making and low-level components
perform most input, computation, and output work.
– Middle-level components perform some control and do moderate
amounts of work.
• Perform “second-level factoring.”

flow model
“Transform” mapping
a
b
c
d e f
g h
i
j
x1
x2 x3 x4
b c
a
d e f g i
h j

“decision
making” modules
typical “worker” modules
direction of increasing
decision making

main
program
controller
input
controller
processing
controller
output
controller

D
C
B A
A
C
B
mapping from the D
flow boundary outward
main
control