Performance Metrics used in Design of Software Architecture

The software architect is the designated experts who are responsible for successful software or product development in term of definition, architectural design, delivery, and maintenance. While designing any software, one of the crucial skills of the architect is to design the architecture of the software by following different acceptable principles which would enable them to develop scalable, flexible, maintainable and stable software. Software architecture is the fundamental structure of the software system consisting of software components, the relationship between these components and the visible attributes of these components. There are four distinct types of software architecture from an enterprise point of view that can be classified into business, application, information, and information technology architectures. While designing these software architectures several principles are followed by the architect. These principles include(a) the SOLID principle(2)Economics Principle.

Further the SOLID principle includes

  • S-Single Responsibility Principle O-Open-Closed Principle
  • S-Liskov Substitution Principle
  • I-Interface Segregation Principle
  • D-Dependency Inversion Principle

Economics principle includes

  • Opportunity Cost Principle
  • Last Responsible Moment or Cost of Delay Principle

These principles are followed to satisfy different qualities such as security, scalability, performance, profitability, risk, maintainability, etc. of the software system. So there is a need to view the architecture from different standpoints like principles, standards, patterns and anti-patterns, rules of thumb and empirical practices which are essential for decision making and evaluating the success of software. The architectural principles which guide and drive the designer to build a high performance and cost-effective product. However, while following the principles to design the software architecture different performance metrics are used by the designer to measure the performance of the software architecture which helps the developer to produce quality software for the users. The most widely used performance metrics of software architecture are presented in this article.


The important features of quality software architecture include the following:

  1. Maintainability: Maintainability is defined as the degree to which software is understood, repaired, or enhanced. We should easily make changes in software, either for the addition of a new feature or for a bug fix. It enables parallel works by providing multiple developers to work on separate parts of the software without impacting each other. Maintainability is often synonymous with sustainability, as it makes it possible for the software project to be used and updated for many years.
  2.  Extensibility: Extensibility is the ability of software architecture to handle the addition of new functionalities and components. It is very valuable in agile development as features are added throughout the life of the project.
  3.  Simplicity, Understandability: Making a software architecture as simple as possible is key to make it most understandable for everyone. It is used to represent the complexity of the architecture. Generally, the software architecture is complex, but the goal is to make it as simple as possible because a simpler architecture is more maintainable, easier to communicate and more reliable.
  4. Re-usability: Reusability is the use of existing assets in some form within the software product development process that are products and by-products of the software development life cycle and include code, software components, test suites, designs, and documentation. It is very valuable to re-use previous projects to make development and design quicker. Making software architecture re-usable is good to save on future projects.
  5. Performance: This would help with choosing the best architecture for performance before even starting to develop anything, as no implementation trick can compensate for the poor performances of bad design.


  1. Coupling and cohesion: At the architecture level, the metric which is the most used is coupling, and its complementary, cohesion. Generally, it is important to have a high cohesion in modules, and a low coupling throughout the architecture. Low coupling diminishes the risk of the ripple effect when making changes in the program and drives to keep the architecture maintainable. Static coupling and dynamic coupling is a measurement at the object level. Another metric decoupling is used to measure the modularity of the architecture. Good modularity means easy maintenance and re-usability.
  2. Complexity: It is another very important metric that affects the understandability and performance of the architecture It can be expressed by the number of classes in architecture or the number of links between classes in architecture.
  3. Change and Propagation: Change Propagation evaluates the maintainability of an architecture based on the probability that a change in a class will have an impact on other classes. It helps in measuring the cost of corrective maintenance, whereas requirements propagation deals with adaption to a change in requirements. It allows the architects for making a component easily adaptable. Error propagation is based on component-based architecture, introducing metrics to compute the error propagation in a system, using a stochastic approach. These metrics are used to gain insight into the future maintainability of a system.
  4. Pattern Density:This is an important metric, which measures the percentage of class in the architecture that is part of a design pattern. It helps the designer to evaluate the maturity of architecture. In more mature architecture we can put more design patterns into it to make higher design pattern density. A framework with high pattern density is more understandable and performing. This metric can be a very good way to express the maintainability and understandability of the architecture design.
  5. Performance Evaluation through Architecture: It includes architecture metrics like, schedulable, utilization, and throughput, etc. that can be used to improve the performance of the software system.
  6. Modularity: Modularity is the degree to which a system’s components may be separated and recombined, often with the benefit of flexibility and variety in use. The concept of modularity is used primarily to reduce complexity by breaking a system into varying degrees of interdependence and independence across and hide the complexity of each part behind abstraction and interface. A very modular project is easier to maintain in the long term and can easily be extended. This is defined
  • to measure the coupling between modules
  • to encourage the usage of proper APIs between the modules of the software
  • to count the number of inter-module calls that are not made through the defined API
  • to detect inheritance between classes of different modules
  • to assess that the higher level of abstraction is the one used by classes outside the module (Liskov Substitution Principle)
  • to assess that interfaces are holding a single responsibility.
  • to check some of the SOLID principles.

7. UML Diagrams evaluation: To evaluate different aspects of UML diagrams three different metrics are used.

    1. Information content(IC): If the IC is higher then higher the amount of information are delivered
    2. The visual effect, which helps in accessing understandability. The higher the visual effect, the more complex it is for a human being to comprehend the diagram at a glance.
    3. Connectivity degree measures the number of association’s w.r.t. the numbers of entities in the diagram. Different types of associations have different weights. These metrics can be used to assess the scale, complexity, and stability of a given architecture.
  1. Methodologies for Architectural Evaluation in Agile Environment: The advantages of such methodologies are that the product is more resilient in the event of changing requirements. But these methodologies also emphasize on not having too much documentation.
  2. Sustainability: Software architecture comprises not only a system’s core structure but also essential design decisions. So, to achieve sustainable architecture, we need sustainable design decisions. In correspondence with Heiko Koziolek’s definition of architecture sustainability, architectural design decision sustainability involves
  • The time duration when the right and relevant decisions remain unchanged, and
  • The cost efficiency of required changes to those decisions.

The different metrics used here are (a)cyclic dependency index to improve modifiability(b)layer organization index to improve layering(3)module interaction index to improve API usage(4)module size uniformity index to minimize the size of module(5)normalized testability index to make efficient testing(6)association induced coupling to reduce internal variable usage.

The details of the performance metrics analysed above have been summarized in Table No.1.

Table No. 1

Cohesion and Coupling Maintainability and reusability
Complexity Understandability and performance
Change and Propagation Maintainability and adaptability
Design Pattern Density Maintainability and understandability
Performance Evaluation through Architecture Performance
Modularity Maintainability and extensibility
UML Diagram evaluation Understandability, stability
Methodologies for Architectural Evaluation in Agile Environment Adaptability
Sustainability Reusability


The demands for developing quality software have been diversified due to which the design should be based on the selection of an efficient design principle that would suit and adopt the latest technologies to satisfy the user requirement. The performance metrics that can be used to measure the performance of a selected software architecture design principles have been explained in this article. As per the requirements of the user the architecture design principles can be used their performance can be measured by using appropriate metrics to provide and develop quality software.

Leave a reply