Cs 1023 lec 6 architecture (week 1)

Copyright © Richard N. Taylor, Nenad Medvidovic, and Eric M. Dashofy. All rights reserved.
Architectural Styles
Software Architecture
Lecture 5

Foundations, Theory, and PracticeSoftware ArchitectureSoftware Architecture
2
Object-Oriented Style
 Components are objects
Data and associated operations
 Connectors are messages and method invocations
 Style invariants
Objects are responsible for their internal representation
integrity
Internal representation is hidden from other objects
 Advantages
“Infinite malleability” of object internals
System decomposition into sets of interacting agents
 Disadvantages
Objects must know identities of servers
Side effects in object method invocations

3
Object-Oriented LL
Software Architecture: Foundations, Theory, and Practice; Richard N. Taylor, Nenad Medvidovic, and Eric M. Dashofy; © 2008 John Wiley & Sons, Inc. Reprinted with permission.

4
OO/LL in UML

5
Layered Style
 Hierarchical system organization
“Multi-level client-server”
Each layer exposes an interface (API) to be used by
above layers
 Each layer acts as a
Server: service provider to layers “above”
Client: service consumer of layer(s) “below”
 Connectors are protocols of layer interaction
 Example: operating systems
 Virtual machine style results from fully opaque layers

6
Layered Style (cont’d)
 Advantages
Increasing abstraction levels
Evolvability
Changes in a layer affect at most the adjacent two
layers
Reuse
Different implementations of layer are allowed as long
as interface is preserved
Standardized layer interfaces for libraries and
frameworks

7
Layered Style (cont’d)
 Disadvantages
Not universally applicable
Performance
 Layers may have to be skipped
Determining the correct abstraction level

8
Layered Systems/Virtual Machines

9
Layered LL

10
Client-Server Style
 Components are clients and servers
 Servers do not know number or identities of clients
 Clients know server’s identity
 Connectors are RPC-based network interaction
protocols

11
Client-Server LL

12
Data-Flow Styles
Batch Sequential
Separate programs are executed in order; data is
passed as an aggregate from one program to the
next.
Connectors: “The human hand” carrying tapes
between the programs, a.k.a. “sneaker-net ”
Data Elements: Explicit, aggregate elements passed
from one component to the next upon completion of
the producing program’s execution.
 Typical uses: Transaction processing in financial
systems. “The Granddaddy of Styles”

13
Batch-Sequential: A Financial
Application

14
Batch-Sequential LL
Not a recipe for a successful lunar mission!

15
Pipe and Filter Style
 Components are filters
Transform input data streams into output data streams
Possibly incremental production of output
 Connectors are pipes
Conduits for data streams
Filters are independent (no shared state)
Filter has no knowledge of up- or down-stream filters
 Examples
UNIX shell signal processing
Distributed systems parallel programming
 Example: ls invoices | grep -e August | sort

16
Pipe and Filter (cont’d)
 Variations
Pipelines — linear sequences of filters
Bounded pipes — limited amount of data on a pipe
Typed pipes — data strongly typed
 Advantages
System behavior is a succession of component behaviors
Filter addition, replacement, and reuse
Possible to hook any two filters together
Certain analyses
Throughput, latency, deadlock
Concurrent execution

17
Pipe and Filter (cont’d)
 Disadvantages
Batch organization of processing
Interactive applications
Lowest common denominator on data transmission

18
Pipe and Filter LL

19
Blackboard Style
 Two kinds of components
Central data structure — blackboard
Components operating on the blackboard
 System control is entirely driven by the blackboard state
 Examples
Typically used for AI systems
Integrated software environments (e.g., Interlisp)
Compiler architecture

20
Blackboard LL

21
Mobile-Code Style
 Summary: a data element (some representation of a
program) is dynamically transformed into a data
processing component.
 Components: “Execution dock”, which handles receipt of
code and state; code compiler/interpreter
 Connectors: Network protocols and elements for
packaging code and data for transmission.
 Data Elements: Representations of code as data;
program state; data
 Variants: Code-on-demand, remote evaluation, and
mobile agent.

22
Mobile Code LL
Scripting languages (i.e. JavaScript,
VBScript), ActiveX control,
embedded Word/Excel macros.

23
Implicit Invocation Style
 Event announcement instead of method invocation
“Listeners” register interest in and associate methods with
events
System invokes all registered methods implicitly
 Component interfaces are methods and events
 Two types of connectors
Invocation is either explicit or implicit in response to events
“Announcers” are unaware of their events’ effects
No assumption about processing in response to events

24
Implicit Invocation (cont’d)
 Advantages
Component reuse
System evolution
Both at system construction-time & run-time
 Disadvantages
Counter-intuitive system structure
Components relinquish computation control to the
system
No knowledge of what components will respond to
event
No knowledge of order of responses

25
Publish-Subscribe
Subscribers register/deregister to receive specific
messages or specific content. Publishers broadcast
messages to subscribers either synchronously or
asynchronously.

26
Publish-Subscribe (cont’d)
 Components: Publishers, subscribers, proxies for managing
distribution
 Connectors: Typically a network protocol is required.
Content-based subscription requires sophisticated
connectors.
 Data Elements: Subscriptions, notifications, published
information
 Topology: Subscribers connect to publishers either directly or
may receive notifications via a network protocol from
intermediaries
 Qualities yielded: Highly efficient one-way dissemination of
information with very low-coupling of components

27
Pub-Sub LL

28
Event-Based Style
 Independent components asynchronously emit and receive
events communicated over event buses
 Components: Independent, concurrent event generators
and/or consumers
 Connectors: Event buses (at least one)
 Data Elements: Events – data sent as a first-class entity over
the event bus
 Topology: Components communicate with the event buses,
not directly to each other.
 Variants: Component communication with the event bus may
either be push or pull based.
 Highly scalable, easy to evolve, effective for highly distributed
applications.

29
Event-based LL

30
Peer-to-Peer Style
 State and behavior are distributed among peers
which can act as either clients or servers.
 Peers: independent components, having their own
state and control thread.
 Connectors: Network protocols, often custom.
 Data Elements: Network messages

31
Peer-to-Peer Style (cont’d)
 Topology: Network (may have redundant connections
between peers); can vary arbitrarily and dynamically
 Supports decentralized computing with flow of control
and resources distributed among peers.
 Highly robust in the face of failure of any given node.
 Scalable in terms of access to resources and
computing power.
But caution on the protocol!

32
Peer-to-Peer LL

33
Heterogeneous Styles
 More complex styles created through composition of
simpler styles
 REST (from the first lecture)
Complex history presented later in course
 C2
Implicit invocation + Layering + other constraints
 Distributed objects
OO + client-server network style
CORBA

34
C2 Style
An indirect invocation style in which independent
components communicate exclusively through
message routing connectors. Strict rules on
connections between components and connectors
induce layering.

35
C2 Style (cont’d)
 Components: Independent, potentially concurrent
message generators and/or consumers
 Connectors: Message routers that may filter,
translate, and broadcast messages of two kinds:
notifications and requests.
 Data Elements: Messages – data sent as first-class
entities over the connectors. Notification messages
announce changes of state. Request messages
request performance of an action.
 Topology: Layers of components and connectors,
with a defined “top” and “bottom”, wherein
notifications flow downwards and requests upwards.

36
C2 LL

37
KLAX

38
KLAX in
C2

39
Distributed Objects: CORBA
 “Objects” (coarse- or fine-grained) run on heterogeneous hosts,
written in heterogeneous languages. Objects provide services
through well-defined interfaces. Objects invoke methods across
host, process, and language boundaries via remote procedure calls
(RPCs).
 Components: Objects (software components exposing services
through well-defined provided interfaces)
 Connector: (Remote) Method invocation
 Data Elements: Arguments to methods, return values, and
exceptions
 Topology: General graph of objects from callers to callees.
 Additional constraints imposed: Data passed in remote procedure
calls must be serializable. Callers must deal with exceptions that
can arise due to network or process faults.
 Location, platform, and language “transparency”. CAUTION

40
CORBA Concept and
Implementation

41
CORBA LL

Cs 1023 lec 6 architecture (week 1)

More Related Content

What's hot (20)

Viewers also liked (15)

Similar to Cs 1023 lec 6 architecture (week 1) (20)

More from stanbridge (20)

Recently uploaded (20)

Cs 1023 lec 6 architecture (week 1)

Editor's Notes