Question 1 (50 POINTS): Below is a matrix with rows corresponding to the 4 selec
ID: 3871887 • Letter: Q
Question
Question 1 (50 POINTS): Below is a matrix with rows corresponding to the 4 selected architectural styles as N-Tier, Event-Driven, Main Program and Subroutines, Persistence Framework and columns representing the software design principles so that an entry [i, j] in this matrix corresponds to a pair [architectural style, software design principle]. Compare each architectural style with respect to software design principles it implements in your own words. Based on your comparisons, list these architectural styles in decreasing order of your preference. Please justify your listing.
Separation of concens Keep it simple and Design for chan Design for change is Separation of achieved by reducing concerns is the dependenciesaccomplished by among the tiers so that changes made to and assigning one tier would not affect the other Information hidin (See design for change.) High cohesion A consequence of separation of concerns Low couplin Design the tiers so each is responsible for one set of core functions, and lower- level re spon sibilities are delegated to the next tier N-tier properly partitioning responsibilities to tiers Main program Design the modules so that each is assigned a distinct functionality Design the modules Design the modules so that eadh accomplishes a core and data functionality to minimize control subroutines dependencies among the modules Components are loosely coupled via the controller, as a conseque nce of design for change. Event Make the compone nts drivenindependent from each other and inte ract only with the controller. This facilitates change A con sequence of high cohesion, resulting in "stupid The persistence Persistence Design the system so Database concerns framework database functions are are separaed fromframe work hides the store and re trieve Responsibilities to given to persistenceobjects and assigned framework. Thus, change to database has little impact to business objects database different types of objects are assigned to different database access commands achieving high cohesion. implementation detail. to the framework. ects.Explanation / Answer
Architectural Style
Software Design Principles
Design for Change
Separation of Concerns
Information Hiding
High Cohesion
Low Coupling
KISS: Keep It Simple/Stupid
N-Tier
N-Tier is an interactive system. So changes made should be not dependent to other tiers.
The problems and concerns are isolated to a single tier. Divide your application into distinct features with as little overlap in functionality as possible
The information to a layer is hidden to reduce its effect to other layers. . A component or object should not know about internal details of other components or objects.
The functions of a tier are highly relevant to modules core functionality. Each component or module should be responsible for only a specific feature or functionality, or aggregation of cohesive functionality.
Reduce the run time effect and change impact to other tiers
Only design what is necessary.
Main Program and Subroutines
Applications can be added to or removed without having an impact on the existing applications.
The functionality can be clearly divided and isolated among the submodules.
Security of information is low
The set of applications that make up a complex process, or the communication patterns between applications, can be changed easily to match changes in business or user requirements
There is no dependency on the application itself, allowing changes, updates, and replacements that expose the same interface
It can’t be kept simple. These are always complicated tasks
Event-Driven
Components should be independent of each other. Components are usually designed to be reused in different scenarios in different applications.
Components are designed to have minimal dependencies on other components.
Components expose interfaces that allow the caller to use its functionality, and do not reveal details of the internal processes or any internal variables or state.
Components may be readily substituted with other similar components.
Components are designed to operate in different environments and contexts
A component can be extended from existing components to provide new behavior
Persistence Framework
Each service is maintained, developed, deployed, and versioned independently.
Each service is independent of others, and can be replaced or updated without breaking applications that use it as long as the interface is still compatible.
Services can be located anywhere on a network, locally or remotely, as long as the network supports the required communication protocols.
Because the protocols and data formats are based on industry standards, the provider and consumer of the service can be built and deployed on different platforms.
Services are autonomous and accessed through a formal contract, which provides loose coupling and abstraction.
Services can be granular in order to provide specific functionality, rather than duplicating the functionality in number of applications, which removes duplication.
These list the architectural styles in decreasing order preference
N Tier Architecture
Advantages
Disadvantages
Main Program and Subroutines
Advantages
Disadvantages
Event-Driven System
Advantages
Disadvantages
Persistence Framework
Advantages
Disadvantages
Architectural Style
Software Design Principles
Design for Change
Separation of Concerns
Information Hiding
High Cohesion
Low Coupling
KISS: Keep It Simple/Stupid
N-Tier
- Interactive System
N-Tier is an interactive system. So changes made should be not dependent to other tiers.
The problems and concerns are isolated to a single tier. Divide your application into distinct features with as little overlap in functionality as possible
The information to a layer is hidden to reduce its effect to other layers. . A component or object should not know about internal details of other components or objects.
The functions of a tier are highly relevant to modules core functionality. Each component or module should be responsible for only a specific feature or functionality, or aggregation of cohesive functionality.
Reduce the run time effect and change impact to other tiers
Only design what is necessary.
Main Program and Subroutines
- Transformational System
Applications can be added to or removed without having an impact on the existing applications.
The functionality can be clearly divided and isolated among the submodules.
Security of information is low
The set of applications that make up a complex process, or the communication patterns between applications, can be changed easily to match changes in business or user requirements
There is no dependency on the application itself, allowing changes, updates, and replacements that expose the same interface
It can’t be kept simple. These are always complicated tasks
Event-Driven
- Event-Driven System
Components should be independent of each other. Components are usually designed to be reused in different scenarios in different applications.
Components are designed to have minimal dependencies on other components.
Components expose interfaces that allow the caller to use its functionality, and do not reveal details of the internal processes or any internal variables or state.
Components may be readily substituted with other similar components.
Components are designed to operate in different environments and contexts
A component can be extended from existing components to provide new behavior
Persistence Framework
- Object-Persistence Subsystem
Each service is maintained, developed, deployed, and versioned independently.
Each service is independent of others, and can be replaced or updated without breaking applications that use it as long as the interface is still compatible.
Services can be located anywhere on a network, locally or remotely, as long as the network supports the required communication protocols.
Because the protocols and data formats are based on industry standards, the provider and consumer of the service can be built and deployed on different platforms.
Services are autonomous and accessed through a formal contract, which provides loose coupling and abstraction.
Services can be granular in order to provide specific functionality, rather than duplicating the functionality in number of applications, which removes duplication.
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.