Let’s briefly understand what quality is. Quality can be defined in a variety of ways. The definition of quality may differ from one person to another. But finally, there should be some standards or guidelines.
Quality can be defined as
- Degree of excellence – Oxford Dictionary
- Fitness for purpose – Edward Deming
- Best for the customer’s use and selling price – Feigenbaum
- The totality of characteristics of an entity that bears on its ability to satisfy stated or implied needs – ISO
How will a Product Developer define Quality? – The product meets customer requirements.
How will Customers define Quality? – The required functionality is provided in a user-friendly manner.
What You Will Learn:
Software Quality Attributes
Quality may be defined from different perspectives. Quality attributes and characteristics are extremely important in the design of software systems in general. The quality of the product contributes to improved user requirements & satisfaction, clearer software design, and ultimately greater end product quality.
These attributes will help to define what is Software Quality. Now let us see how one can measure the Quality Attributes of a software application or service.
The following factors are used to measure Software Quality. Each attribute can be used to measure product or service performance. These attributes can be further used for Quality Assurance as well as Quality Control.
Quality Assurance activities are oriented towards the prevention of the introduction of defects and Quality Control activities are aimed at detecting defects in products and services.
These Software Quality Attributes in software engineering can be categorized under specific areas as mentioned below:
#1) Design and Software Architecture Quality Attributes
- Conceptual Integrity
#2) Runtime Qualities
- Scalability (Flexibility)
#3) System Qualities
#4) User Qualities
#5) Non-runtime Qualities
We will discuss these software qualities (quality attributes) in detail in the following sections.
Synonym for reliability is assurance. Reliability can be defined as the degree to which a software system or its components or a service performs specific functions under predefined conditions for a set period. It is the likelihood of fault-free software operation for a specified period of time in a specified environment.
It is the measure of the ability of a software application or service to consistently maintain operations in a predefined condition. It is critical to verify that the software is fully functional, especially when under maximum load.
Sub-attributes for reliability are listed below:
- Maturity: It is the extent to which a software product or service meets reliability standards during normal operation.
- Availability: This refers to the ease with which a software application can be accessed by users whenever required.
- Fault Tolerance: It is the extent to which a software application or service functions normally despite any hardware or software issues.
- Recoverability: It defines the extent to which, in the event of an interruption or failure, a software application can recover the data directly affected by the failure.
Example: A multi-storefront application became unavailable one Friday evening as the third-party CDN server went down.
Possible Check: Software organizations can implement the High Availability feature. This feature is used to provide redundancy and fault tolerance. Its purpose is to ensure that this service is always available, even if something goes wrong.
A typical example is to have several servers in a cluster, so that if one of the servers fails the other servers will continue processing seamlessly and take over the load of the failed server. Another method could be to implement automatic failover.
It is the ease with which a software developer is able to fix flaws in the existing functionality without impacting other components of the software system. It also considers the ease with which a developer can add new features, update existing features or upgrade the system with new technology.
Software maintainability is achieved through adherence to software architectural rules and consistency across the application.
The purpose of having this attribute is to make the maintenance of software applications easy and cost-effective.
The software industry typically uses some of the following common maintenance types:
- Corrective: This is the most essential type, where in developer(s) analyses the detected bug and implements a fix for it.
- Adaptive: In this case, the application might be migrated for the use of a different database or technology (e.g. MS SQL to PostgreSQL; from C++ to C#).
- Preventive: Preventive bugs or failures might be a very difficult task. But by implementing proper coding standards, documenting code, avoiding complex code, and doing enough testing, certainly errors can be reduced.
- Perfective: This could involve code refactoring. The idea is to improve the existing code and thereby the feature/functionality.
Example: Due to the intricate nature of the code, implementing a new GDPR in the legacy product (running for more than 20 years) was a true headache for the developers.
Possible check: Software developer(s) should write the code as simple as possible and add comments in the code (in-line or block comments) wherever necessary.
This attribute refers to the quality of the end user’s experience while interacting with the application or service. Usability is concerned with effectiveness, efficiency, and overall user satisfaction.
This attribute helps to measure the ease of use of any software application or service (e.g., registering a new account and then signing in to the account)
A few of the following problems can arise if usability is not taken care of correctly:
- Complex sign-up process
- Inconsistency in UI
- Unclear navigation and at times complicated.
- Error messages not user friendly
Sub-attributes for usability are listed below:
- Simple & Intuitive Design: It describes the user’s ability to effortlessly understand the design of the application and navigate without any conscious reasoning.
- Learnability: It refers to the ease and speed with which a user who has never seen the user interface before can execute the most basic tasks.
- Usage Efficiency: It means how fast a user can accomplish tasks once he/she gets an experience of the system.
- Memorability: It describes how well a user can use an application (site) effectively, after not using it for a while.
- Error Frequency and Severity: It refers to how frequently users make mistakes while using the system, how serious the errors are, and how users recover from these errors.
- Subjective Fulfillment: It describes how well the system is liked by the user.
Example: A web application for scientists and research students had all of the necessary features, however, some of the sub-menus on one or more pages were concealed (for instance, they were only seen after clicking the ellipsis button). As a result, users had a tough time understanding how to start using those features.
Possible Check: As far as possible, UI design should be maintained as simple, intuitive, and from the end user’s perspective. An adequate quantity of usability testing should be performed.
It refers to the extent to which a system or its components can be migrated (transported) to other environments consisting of different hardware and/or different software (operating system). The importance of software portability should not be underestimated.
Sub-attributes for portability are listed below:
- Adaptability: It refers to how easily a software system can be adapted to new hardware, software, or another environment.
- Replaceability: It refers to how effectively one software product can replace another software solution designed for the same purpose. It is the capability of one software component to be replaced by another one.
- Installability: It specifies the ease with which a software solution can be installed or uninstalled in a given environment.
- Compatibility (Co-existence): It is the degree to which multiple, unrelated software systems and/or components co-exist in the same environment.
Example: Mobile version of event booking software was working fine on Android but had issues with context menus on iOS (iPhone as well as iPad)
Possible Check: During the development phase, software portability should be given careful consideration. There should be a clear and generalized abstraction between business logic and system interfaces. CSS/styling should be implemented with diverse OS platforms in mind, for example, Portability testing should be given enough importance.
This refers to the ability of software products or services to perform tasks (e.g. calculations, sign-ups, navigations) correctly as specified by the predefined requirements when used under specified conditions.
It is a measure of whether a software system is correct or not, implying that it is an all-or-nothing attribute.
Example: An online examination system had a remote proctoring feature. As per the specification, it was required to have the option to enable/disable this functionality as required and to work on all current browser versions. But in the production environment, the admin user couldn’t disable this functionality on Firefox.
Possible Check: Code review must always be a part of the DOD (definition of done). Also, a static review of the specification document is essential.
It is one of the most important software quality attributes. It reveals the performance of a software product concerning the number of resources utilized under predefined conditions. It is measured simply in terms of the time required by the software system or service to complete any given task.
Software application performance management is thus critical to any organization.
A software application can be said as inefficient from the user’s perspective when it utilizes too many resources of the system (machine) that slow down other applications or the entire machine.
Also Read => Best Performance Monitoring Tools
Sub-attributes for efficiency are listed below:
- Time Behavior: It refers to the extent to which a software application or service satisfies the predefined response time required to respond to user action(s).
- Resource Utilization: It determines how well a software system satisfies predefined specifications of using system (machine) resources.
- Capacity: It defines how much demand (actions) the application can handle while continuing to meet the specified requirements.
Example: A survey application was collecting data, which could be downloaded as an MS Excel file. However, the applications started freezing with approximately 5000 records.
Possible Check: Enough consideration should be given to performance testing with a varied amount of data and in different environments.
Recommended Reading =>> What is Efficiency Testing?
It is defined as the capacity of a system to fend off or thwart malicious or unauthorized attempts to intrude and damage it while still allowing access to authorized users. Additionally, it also measures the ability of the software system to safeguard data and information from unauthorized entities.
As in recent years, the number of cyber-attacks are on the rise, security of a software system should be given very high priority.
It also consists of authorization and authentication techniques, safeguarding against network attacks, sending encrypted data wherever necessary, prevent SQL injection.
Sub-attributes for security are listed below:
- Confidentiality: This is the extent to which a software application or service ensures that only authorized users can access information and data.
- Authorization and Authentication: This refers to the ability of the application to recognize the identity of the user visiting the system.
- Integrity: It defines the ability of the software application to prevent unauthorized access to the application’s data by any external program (other application).
- Accountability: It determines how well a software application monitors, tracks, and records a user’s activity (which could be required in certain cases – say, legal dispute)
Example: One of the APIs of a large customized survey application was accessible without proper authentication. Although only technically skilled individuals could have utilized that API, it posed a significant security risk.
Possible Check: It is extremely critical to conduct at least basic security testing. However, due to time constraints, security checks and testing are sometimes not given adequate time.
It defines the ease with which QA and other beta users can test the software application and detect bugs. It also evaluates the ease with which the testing personnel can design test criteria for the application and its various components.
Another criterion could be the number of test cases or features that can be automated so that the testing process itself can be automated.
In simple terms, testability identifies how fast a system can be tested to ensure quality against predefined specifications.
Example: Several issues were introduced in a web application as a result of an anti-design framework version update and the failure to identify the impact of the upgrade on current functionality. The system became highly unstable and as a result, testing was nearly impossible.
Possible Check: It is best practice for developers to analyze and determine the impact of every change (whether new changes or modifications to existing functionality) so that the software system is stable enough to continue testing. Developers should carry out corresponding unit tests before committing the code to the version control system.
#9) Flexibility (Modifiability)
It is the degree to which software applications can adapt to future changes (e.g., upcoming technologies, market trends, business rules, regulations, etc.)
A software application can be called flexible if it can run smoothly on any type of device, hardware platform, and/or operating system. It should be easy to interface with any other software products, third-party software, or libraries.
The ability to create new business opportunities is a clear advantage of flexible software. You can gain a competitive advantage in your functional area and thus drive more customers by enhancing your existing software with new features and integrations.
Example: The developers found it challenging to integrate a custom-developed ticket creation software system with other applications since the APIs were not correctly accessible to external calling apps.
Possible Check: Developers should always keep the code base accommodative. APIs of the application(s) that may be integrated with other systems should be made available using appropriate API keys and other authentication mechanisms. Any assumptions should be avoided. Some tips & tricks of flexible code can be used by developers.
This attribute relates to the software system’s capability to handle the increased load (usage) without degrading its performance. The industry (the software industry in particular) should always consider the importance of software scalability.
There are two distinct ways in which the scalability of a software application can be measured:
- Vertical Scalability: This can be achieved by adding more resources such as memory, hard discs, and/or processors.
- Horizontal Scalability: This can be fulfilled by adding extra computer systems (e.g. load balancers, servers) and distributing the load between these server systems.
Example: A multi-storefront application began acting inexcusably sluggish after a lot of data was saved in the system. The database size used was not optimum. The usage of larger-sized images, instead of thumbnails also contributed to the sluggishness of the application.
Possible Check: The developer architect and configuration team together should determine the optimum size of the database and other required resources. DB indexes should be used wherever necessary to speed up querying. Consider implementing lazy loading in a web application with large sets of data.
Also, refer to Scalable Web apps – Design principles
It refers to the ability of the application to integrate seamlessly with other software applications under prescribed conditions and perform its actions efficiently while sharing the same hardware and software (e.g. Operating system). The app should be able to work as expected on different devices, hardware, and software platforms.
It also considers the ability of software applications (in this case web applications) to work correctly on different types of browsers and their several versions.
Along with forward compatibility (compatibility with newer versions), it is important to consider backward compatibility as well (e.g. ensuring that web applications work on now-defunct IE).
Sub-attributes for compatibility are listed below:
- Interoperability: It outlines the extent to which data can be shared and reused between two or more software systems.
- Co-existence: It describes how well a software application can perform its primary functions while sharing a common software and/or hardware environment with other software products without interfering with the performance of other applications or systems.
Example: A web application developed for research activities started failing on Firefox and that too for users where the only browser allowed was Firefox. It looks like enough compatibility tests were not conducted.
Recommend Reading => Tools for browser Compatibility testing
It is the degree to which a software application can provide practically useful information helpful for identifying and resolving issues when the application fails to work correctly.
The following factors are to be considered:
- Logging & Monitoring (Diagnosis): It consists of different kinds of logging which provide data by monitoring and controlling the activity and performance of the application.
- Health Checks: These comprise a wide range of tools to measure & control project/build compilation time, build size, deployment time, and several other technical aspects.
Example: PDF downloads for resource booking applications started failing in the production environment (which was working perfectly fine on test & release environments). The lack of sufficient and appropriate error logging information caused a delay in providing the fix for it.
Possible Check: Appropriate information about the event causing the error should be logged. Suitable unit tests should be conducted by simulating certain fault-causing conditions.
It is the degree to which a software application or its components/modules can be reused in other application(s) or the same application (e.g. common components, libraries, etc. can be reused across the application). When it comes to the project budget, software reuse is extremely important.
Reusable components (and any other such resources), also known as cost resources, are extremely beneficial because they help to reduce overall development costs.
Dividing software application code base into common (also referred to as generic) components (wherever possible) is used to facilitate reusability. This kind of development is often referred to as component-based software development.
Some of the following approaches can be considered:
- Code-level application frameworks
- Configurable systems
- Component-based Development
- Use of Commercial-Of-The-Shelf (COTS) libraries (or open-source apps)
- Program Generators
- Using OOPS concepts
- Choose the right design patterns
Example: If the activity feed feature had been built as a common component/micro-service, the time necessary to implement it in a web application may have been significantly reduced (Note: another application had already implemented it but as a part of that application).
Possible Checks: Commonly used features can be identified and developed as shared components. The development team can choose appropriate design patterns.
Also refer to the Software Reuse – Checklist.
It refers to the application’s ability to seamlessly communicate or exchange data between different operating systems, hardware platforms, databases, and protocols (network and/or web protocols) conditions.
Some of the commonly observed interoperability problems are listed below:
- Legacy Systems (Old Code Structure and/or Technology)
- Data formats of similar (or other) external systems are quite different.
- API versions used in system interaction are different.
- No proper coding standards were used.
- Poor code quality.
Example: The development team responsible for building equipment booking software took an unexpectedly long time to integrate the invoicing feature with the external accounting system.
Possible Check: Software systems can be built using commonly used data formats. A certain amount (considering various available applications) of interoperability testing should be done.
Recommended Reading => Cost of Quality and the Cost of Poor Quality
By applying the above software quality attributes and corresponding standards one can determine whether the software system meets the specified requirements of quality or not.
As previously stated, all of these attributes are applied to QA and QC processes so that both the tester and the customer can confirm the application or system’s quality.
Hope you had a good understanding of Software Quality Attributes and their importance.
Please feel free to share your thoughts in the comment section below.