1. OO Methodology
OO Architecture

2. Table of Contents Definition of Software Architecture
Architecture Dimensions and Views
Architectural Patterns
Architectural Pattern: Layers
Partial Logical View of NextGen POS
Inter-Layer and Inter-Package Dependency
Inter-Layer and Inter-Package Interaction
Packages vs Subsystems
Session Facades and Application Layer
Logical vs Process and Deployment Views
Implementation View
Deployment View

3. Definition of Software Architecture
RUP definition of architecture is
The organization of a software system
The selection of structural elements and their interfaces by which the system is composes, together with their behavior as specified in the collaboration among those elements
The composition of these elements into progressively larger subsystems
The architectural style that guides this organization, these elements and their interfaces, their collaboration, and their composition
Buschmann et al.
A software architecture is a description of the subsystems and components of a software system and the relationships between them.
Subsystems and components are typically specified in different views to show the relevant functional and nonfunctional properties of a software system.
The software architecture is the result of the software design activity

4. Architecture Dimensions and Views
The 4+1 View Model of Architecture (P. Kruchten95)
The Logical View
addresses the functional requirements of the system
an abstraction of design model
UML package, class and interaction diagrams
The Implementation View
describes the organization of static software modules(source code, data files, components, executables etc.)
UML package and component diagrams
The Process View
addresses the concurrent aspects of the system at runtime, task, threads or processes as well as their interactions.
allocation of logical elements to them
UML class and interaction diagrams
Logical
View
Implementation
Process
Deployment
Use-Case

5. Architecture Dimensions and Views
Deployment View
addresses physical deployment of processes and components to processing nodes and the network configuration between nodes
UML deployment diagrams
Use Case View
describes the most architecturally significant use cases and their non-functional requirements. UML use case diagrams
Models and Views
A model is a complete representation of the system (at least in one aspect)
Architectural views focuses only on what is architecturally significant. “not all design is architecture”
Architectural views are like slices cut through the various models, illuminating only the important, significant elements of the models.
Architecturally significant elements
has a wide impact on the structure of the system and on its performance, robustness, and scalability etc.
major use cases
major classes
architectural mechanisms
patterns and frameworks
major processes or threads
etc.

6. Architectural Patterns
Three types of Patterns [Buschmann et.al. 1996]
Architectural styles
Design Patterns
Idioms
Architectural Styles
related to the large-scale and coarse-grained design
typically applied when the major structures and connections are established
expresses a fundamental structural organization schema for software system
Example:
Layers
Pipes and Filters
Blackboard
Broker
MVC
related to the small and medium-scale design of objects and frameworks
Example: Singleton, Proxy, Command, Adapter, Facade, Strategy etc.
language or implementation-oriented low-level design solutions
Example: Canonical forms, Java maxim

7. Architectural Pattern: Layers
Layer pattern
organize the large-scale logical structure of a system into discrete layers of distinct, related responsibilities with a clean, cohesive separation of concerns

8. Partial Logical View of NextGen POS

9. Inter-Layer and Inter-Package Dependency

10. Inter-Layer and Inter-Package Dependency

11. Inter-Layer and Inter-Package Interaction
To understand the dynamics of how objects across the layers connect and communicate
Illustrate architecturally significant scenarios
Emphasizes cross-boundary connections

12. Packages vs Subsystems
is a coherent piece of a system that can be treated as an abstract single unit
can be modeled both as a package and as a class
has a behavior and a set of interfaces
Facade
a subsystem provides a public facade object outside the subsystem
a facade object for a entire system
system-wide facade vs session facade

13. Session Facades and Application Layer
application layer contains objects responsible for knowing the session state of clients, mediating between the presentation and domain layers
When multiple user interfaces will be used
When in a distributed system, domain layer is on a different node than presentation layer and shared by multiple clients
When there is a defined workflow in terms of the controlled order of windows or web pages that must be presented

14. Upward Collaboration with Observer
Observer pattern is used for domain objects to communicate upward with the presentation layer, where as Facade pattern is used for downward collaboration

15. Logical vs Process and Deployment Views
The architectural layers are a logical view of the architecture, not a deployment view of elements to processes and processing nodes
There are many ways to slice and dice these logical layers for deployment depending on the platform

16. <<database>>
Physical Views
Physical views include
Implementation view
Deployment view
Implementation View
models the components in a system, that is, software units from which the application is constructed, as well as their dependencies
models the assignment of classes and other model elements to components
displayed on component diagrams
<<database>>
TicketDB
CreditCardCharges
status
charge
purchase
groupSales
TicketSeller
ManageInterface
indivisualSales
subscriptionSales
KioskInterface
ClerkInterface

17. <<database>>
Physical Views
Deployment View
depicts the run-time architecture of processors, devices and the software components that execute in this architecture
physical description of the system topology, describing the structure of the hardware units and the software that execute on each unit
represents the arrangement of run-time component instances and/or objects on node instances 1
CreditCardCharges
ManageInterface
TicketSeller
<<database>>
TicketDB
TicketServer 1 1 * *
KioskInterface
ClerkInterface
Kiosk
SalesTerminal