Software Architecture Principles
Software Architecture has been very important in IT and software development in general. Mainly due to the fact that it can facilitate and comprehend not only the solution management inside the business, but also at the same time it helps to have an accurate and clear communication between the rest of the members and software developers working on the project, whether it is a web app or a mobile app.
But, what is Software Architecture?
Software Architecture is a set of system structures, composed by elements (objects, threads, logical and physical entities, classes, components, etc.) with visible properties of an external way and the existing relations between them.
It’s important that the architecture should:
- Expose the structure of the system but hide the implementation details.
- Realize all of the use cases and scenarios.
- Try to address the requirements of several stakeholders.
- Handle both functional and quality requirements.
Key Design Principles
What can we follow to get a successful system architecture? For getting started with the design, it’s important to focus on those key principles which will help you to create an architecture that adheres to proven principles, reduces costs and maintenance of requirements, and promotes usability and extendibility. Some of key principles are:
- Separation of concerns. Separate your application into distinct sections with as little overlap in functionality as possible. The important factor is to minimize the interaction points to achieve high cohesion and low coupling.
- Single Responsibility principle. It means each component or module should be in charge to only a specific section or functionality, or aggregation of cohesive functionality.
- Principle of Least Knowledge. A component or object from the system should not know about internal details of other components or objects for a better information flow.
- And of course, the 3 Software Development principles: KISS, YAGNI and DRY
5 Key principles Design Considerations
What to determine when we are designing?
1.- Application Type
Selecting the appropriate application type is the key part of the process of designing a webapp or mobile application. Your choice should be based on specific requirements and infrastructure limitations.
2.- Deployment Strategy
Your applications should be supported by a variety of environments, each with its own hardware and software specifications. Also you must balance the requirements of the applications with the suitable patterns that the hardware can support, as well as the constraints that the environment exerts on your deployment options as well.
3.- Appropriate Technologies
For choosing technologies for your applications, it’s important to consider the type of application you are developing and your preferred options for application deployment topology and architectural styles. The choice of technologies will be based on organization policies, infrastructure limitations, resource skills, and so on.
4.- Quality Attributes
Quality attributes, for instance security, usability and performance, can be used to focus on critical problems that design should solve. First understand your requirements and deployment scenarios, to know which quality attributes are important for your design.
Some questions to consider when implementing quality attributes include:
- * What are the main quality attributes required for your application?
- * What are the key requirements for addressing those attributes?
- * What is the acceptance criteria that will indicate you’ve met the requirements?
5.- Crosscutting Concerns
Crosscutting concerns represent key areas of a design that are not related to a specific layer in your application.
- * Instrumentation and Logging: Apply measuring to all of the business-critical and system-critical events, and enter enough details to recreate events in the system without adding sensitive information.
- * Authentication: Define how to authenticate users and pass authenticated identities for a protected system.
- * Authorization: Guarantee appropriate authorization with a pat division within each layer, and across trust boundaries.
- * Exception management: It can be focused by two aspects, one is to catch exceptions at functional, physical and logical boundaries. The other one is to avoid revealing delicate information to end users.
- * Communication: Protect delicate data passing over the network by selecting proper protocols and minimizing calls across the network.
- * Caching: Be sure that you consider Web farm and application farm issues when you identify what should be cached and where to cache. This will improve your application’s performance and responsiveness.
Source:
Microsoft Corporation. (2009, October). Microsoft Developer Network. Retrieved February 14, 2014, from http://msdn.microsoft.com/: http://msdn.microsoft.com/en-us/library/ee658124.aspx#KeyDesignPrinciples
About the Technical Author
Juan Pablo Santiago has been a tester for almost 7 months. He just graduated as a TI technician and now is a TI Engineering student.
Post Your Comment Here