Please enable JavaScript.
Coggle requires JavaScript to display documents.
Software Architecture Design Space - Coggle Diagram
Software Architecture Design Space
Architectural design space
Software architect must understand the software architecture's design space
design alternatives that can support functional and non-functional requirement specifications
Design Space
A software architect’s responsibility
proposing a concrete architecture that best supports the detailed design and implementation of a specific project.
Based on quality attributes
Make the decision by balancing on quality attributes.
Software Structures
Types of Software Structures
Software architecture in multiple Perspectives
Run-time Structure
Management structure (or Deployment structure)
Static Structure
Different structures use different elements and connectors, and have different performance attributes
Software Static Structure
At software development time
Each modules has assigned functional and nonfunctional attributes
API defined for modules separates module’s interface and implementation
The main software elements are source code files
The connectors at this level are in the form of module dependency
Module A is connected to module B, if, A needs to invoke some methods in B during execution.
Static connectors may exhibit some attributes
Synchronization
Can be synchronous or asynchronous
Sequence
Some connectors must be used in a particular sequence.
Direction
If module A invokes a method of module B during execution, there is a unidirectional connection from module A to module B
A software project is typically implemented in multiple files . This includes
Binary software component modules
DLL
JavaBeans
Library files
Executable files
Deployment descriptors
Others resources files
At deployment time
Several source code modules may be packaged into the same deployment unit
The connectors in the deployment structures are basically the same as those for the source module structures
The elements are binary versions of the project modules and files.
Managing Static Structural Representations
Static structure affects the architecture's clarity, construction strategy, maintenance, reengineering, reusability…
It plays a crucial role in the management of large software systems because it deals with the packaging of software modules in order to facilitate system construction and maintenance through a clear portrayal of intermodule relations.
The software static structure
refers to the organization of physical software modules and their interrelations
This structure play a critical roles in software architecture design.
Managing static structures involves layers of
Abstraction for encapsulation
Refinement showing visibility
Two kinds of static hierarchical relations
A linear client-server relation is formed when a component provides primitive abstractions to another component
A tree-like hierarchy of refinement relations is formed when an abstraction is implemented, and recursively divides into subcomponents. A refinement relation specifies how a module (parent) is decomposed into a refinement module (child).
Software Runtime Structure
Software runtime structures serve as the technical backbone of architecture designs and provide the basis from which other structures are derived.
The same element in a code structure can implement or support multiple runtime elements
In a client-server application, the same client module may run on many client computers
These elements may run on the same computer or on multiple computers across a network.
Several code structure elements may implement or support a single runtime element
Many threads may run multiple methods from different classes that may be packaged in different code units
A runtime project consists of elements
Threads
Web services
Processes
Distributed objects
Run-time Connector
inherit attributes from their source-code structure counterparts, with a few extra attributes
Multiplicity
Distance and connection media
Universal invocable
Self-descriptive
Software Elements
At runtime, element is a self-contained component of a system
Has well-defined functions
Connected with each other via connector
Software Architects Job
Map functional requirements to software elements
Rule 1: Reentrant
Rule 2: Handle Bottle-Neck First
Rule 3: Make Things Simple