Architectural Characteristics

Photo by Ricardo Gomez Angel Unsplash

Table of Contents

Architectural Characteristics

Architectural characteristics, describe the desired attributes or properties of a software system’s architecture.

Architectural characteristics help guide the design and implementation of the system to meet specific goals and requirements.

It is also known as non-domain design, non-functional requirements, or architectural qualities.

After system requirements are mapped to architectural characteristics, these characteristics can indicate one or multiple forms of the architectural styles. (These styles can be microservices, event-driven architecture, microkernel, layered monolith, service-oriented architecture, …)

An application can support multiple architectural characteristics but it should not. If an application supports numerous or many architectural characteristics, the application may become more complex. Therefore we should select optimal and minimum architectural characteristics as possible.

All of the architectural characteristics can’t be implemented. One of them can affect to other one. For example in the scenario that security is requested, security can impact performance negatively. (Encryption, Decryption, Hashing, etc. CPU-bound works)

Operational Architectural Characteristics:

Defines operational qualities of the system.

• Availability: How long system should be available? If a system requires high availability (i.e. 7/24), precautions should be taken to avoid crashes.

• Continuity: Disaster recovery capability

• Performance: Stress test, peak analysis, analysis of the frequency of functions used, capacity required response times, CPU usage by request, etc, …

• Recoverability: In the case of failure, how fast system can recover? Decisions taken in terms of recoverability may affect the backup strategy.

• Reliability/Safety: If system has to be safe, or system may affect our life. (e.g. Health applications) If the system crashes how it affect the company, customer, etc?

• Robustness: Ability to catch errors. For example network and power loss.

• Scalability: How system is affected when the user or request count is increased? (e.g. Horizontal/Vertical scaling)

• Elasticity: Ability of system to automatically and dynamically scale its resources up or down to meet changing demands. (e.g. Load balancing)

Structural Architectural Characteristics:

These characteristics affect code.

• Configurability: Capability to change application configuration easily of the end user.

• Extensibility: How hard to extend application’s functionality?

• Installability: Ease of installation of system.

• Leverageability/Reuse: Using the same components in various products. (e.g. code reuse)

• Localization: Multi-language support, currency, and multi-byte characters.

• Maintainability: Ease of developing and updating application.

• Portability: Should system work on different platforms?

• Supportability: How much degree of technical support is required for application?

• Upgradeability: Ease of updating application from older version to newer version.

Cross-Cutting Architectural Characteristics

Those that are important but not in any obvious category.

• Accessibility: For example, can hearing or visually impaired people use application easily?

• Archivability: After the specific time period, should data be removed or archived? (periodically expire, archive, delete, etc.)

• Authentication: Users should authenticate themselves when using the system.

• Authorization: Users have authority and they are only capable of exploring the system according to their authorities.

• Legal: Inspection of the system legally.

• Privacy: Hiding the operation of the system from customers and also from the company’s employees.

• Security: Should the data be encrypted in the database? Should communication of the internal systems be encrypted?

• Usability: Required training level for the users to achieve their goals by using the application.

How to Identify Architectural Characteristics

It is incorrect if we are extracting architectural characteristics from domain concerns and giving them to stakeholders to prioritize them. We should say to them select the three most important from the end list.

Examples:

• If time and budget are important: Simplicity, Feasibility
• If the competitive advantage is important: Agility, Testability, Deployability, Scalability, Availability, Fault Tolerance
• User Satisfaction: Performance, Availability, Fault Tolerance, Testability, Deployability, Agility, Security
• For publishing to the market early: Agility, Testability ,Deployability
• Conjugation: Interoperability ,Scalability, Adaptability, Extensibility.

For example, if the user count is constant and it is known before then scalability may not be required.

Firstly separate architectural characteristics into explicit and implicit ones. The explicit architectural characteristics are extracted from the system requirements. The implicit architectural characteristics are the required ones that do not exist in the system requirements. (e.g. Availability, Security, Reliability).

If there are no statements about implicit characteristics in the system requirements they are handled normally otherwise they are prioritized. For example, in a web application security is important but it is not the most important one so it is handled normally. (Encrypted communication, encryption of the credit card data, etc.) But in the defense industry security may be the most important architectural characteristic and it is prioritized.

Some systems are scalable but not elastic. If the user count will increase from thousand to million in the long term, the system should be scalable. If the request count arresting to the web server varies from thousands to millions, the system should be elastic. (elasticity). They are implemented together generally.

Reliability should be considered when integrating with third-party systems. What happens if the third-party system crashes?

Conclusion

• Architectural characteristics are desired attributes or properties of a software system’s architecture.
• They guide the design and implementation of the system to meet specific goals and requirements.
• They can be operational, structural, or cross-cutting in nature.
• Operational characteristics include availability, continuity, performance, recoverability, reliability/safety, robustness, scalability, and elasticity.
• Structural characteristics affect the code and include configurability, extensibility, installability, leverageability/reuse, localization, maintainability, portability, supportability, and upgradeability.
• Cross-cutting characteristics include accessibility, archivability, authentication, authorization, legal compliance, privacy, security, and usability.
• It is important to identify the most important architectural characteristics based on stakeholder priorities.
• Implicit architectural characteristics, such as availability, security, and reliability, should be considered even if not explicitly stated in the system requirements.
• Scalability and elasticity are related but distinct characteristics, with scalability focusing on handling increased user or request counts, while elasticity involves automatic resource scaling.
• Reliability should be considered when integrating with third-party systems to handle potential failures.