Software Quality Management

Oxford dictionary defines quality is as follows as ‘General excellence of standard or level.’ However, our world has progressed to extreme complexities and dynamics such that a single definition becomes obsolete. Quality over the certain level of expectation becomes really subjective not just to the product or service domain but also to the target customer. The word has ‘Quality’ has its origin in Middle English as ‘character, disposition’ and ‘particular property or feature’ and from Old French ‘quality’, from Latin ‘quality’ translating Greek poiotes, from qualis ‘of what kind, of such a kind’. [2] Quality is such a complex word to be used generally without defining in maximum precision.

Delivering software systems that meet business needs has always been a challenge for IT organizations. Software development and engineering are professions which are in its infancy; however, they are widely practiced and growing faster than ever before. India’s lion share of GDP comes from Software and IT&ITES industry. The software industry is one of the main pillars of economic growth in many countries. Companies quite often face many difficult challenges to deliver high-quality software, and they strive to achieve customer satisfaction.

Forrester, which is a famous research entity defines quality software as "Software that meets business requirements, provides a satisfying user experience, and has fewer defects.”. This is definitely not an all-encompassing definition but surely this somewhere we can start. [3]

Necessity of quality

Software became an indispensable part of our daily lives, demand for software increased significantly. High software quality is now perceived as a "must have" rather than "should have." It's essential to involve quality assurance teams in the project planning and execution from the very beginning. Yet companies that consider software quality as merely a task that is done by testers at the end of the development lifecycle still exist in our world.

The bugs in software’s are called so for a reason: These bugs have been around for a long time, they always turn up in code at the most inopportune times, and there's no proven way to eradicate their existence. The brutal business climate, a dearth of time and staff as well intense cost pressures—have made "the need for speed" a more apt mantra for development teams rather than assuring that "quality is job No. 1."

First things first

It's worth noting that the software market is full of alternatives, and there is plenty of free, open source software out there. Besides that, customers and end users are becoming more aware of the quality of the software that they buy. Applications or enterprise systems that show poor performance or low-quality user experience will be eliminated, and other products will take their place easily. Now it's the mission of software companies to take care of the quality of their products as never before.

Forrester Research report 2017,” Seven Pragmatic Practices to Improve Software Quality”, offers practical, reality-based ways teams can make progress on improving their code's quality. The main points discussed are [3].

1. 1. Define Quality to Match The Needs:

Impact on Quality: Meet business requirements; achieve a satisfying user experience.

Benefit: The ability to achieve quality is improved because the application development team is not charged with unrealistically perfect expectations. Rather, it is chartered with a definition of quality that fits the given time, resource, and budget constraints.

Relevant Roles: Business stakeholders; entire application development team.

1. 1. Broadcast Simple Quality Metrics:

Impact on Quality: Reduce defects.

Benefit: Highly visible metrics keep the quality top of mind for the entire team and expose when efforts fall short.

Relevant Roles: Entire application development team.

1. 1. Fine-Tune Team/Individual Goals to Include Quality:

Impact on Quality: Meet business requirements; achieve a satisfying user experience; reduce defects.

Benefit: Team members perform according to their incentives, making quality improvement part of their goals reinforces desirable behavior.

Relevant Roles: Management.

1. 1. Get the Requirements Right:

Impact on Quality: Meet business requirements; achieve a satisfying user experience.

Benefit: Less rework means less retesting and fewer cycles, which greatly reduces the overall effort.

Relevant Roles: Managers, business analysts, user experience designers, architects.

1. 1. Test Smarter to Test Less:

Impact on Quality: Reduce defects.

Benefit: A focus on testing the most crucial and at-risk areas ensures that they receive the lion's share of test resources and that any bugs that slip through are likely to be confined to the least-important features.

Relevant Roles: Quality assurance, managers.

1. 1. Design Applications to Lessen Bug Risk:

Impact on Quality: Reduce defects.

Benefit: Simpler, cleaner designs result in code that is simpler, cleaner, and easier to test and rework—which means that the code will have fewer bugs and that those bugs will be easier to diagnose and repair.

Relevant Roles: Architects, developers.

1. 1. Optimize the Use of Testing Tools:

Impact on Quality: Reduce defects.

Benefit: Automation frees resources from mundane testing to focus on the highest-priority tests and increases test cycles' repeatability.

Relevant Roles: Quality assurance, developers.

Software quality is a team sport, and everyone needs to play. "Quality must move beyond the purview of just QA professionals to become an integrated part of the entire software development life cycle to reduce schedule-killing rework, improve user satisfaction, and reduce the risk of untested non-functional requirements such as security and performance," they write. "Managers must make quality measurable and incentivize all roles on the team to improve it."

Software quality considered from beginning to end

During the testing phase, the developers do their best to assure that their code has minimal defects. Then the tester works hard to uncover every possible defect in the software, while the managers and clients hope that they have software ready to release to market.

Rushing through development might save the team's time at a given moment, but it ultimately takes them more time to do it over if there were major development issues not considered from the beginning. It results in wasting a lot of the team's resources in fixing and re-engineering their code instead of investing those resources in something more useful. Software teams know the whole story by heart, but with nagging clients and strict sales team accompanied by some developers' egos that they write defect-free software, it's really hard to escape dropping QA aside to rally behind just finishing the code.

Software engineering standards and their use

It's worth mentioning that companies need not necessarily follow one of the software development standards nor have a strict process in place. There are various standards for the typical software development life cycle (SLDC), such as IEEE, ISO - 12207, or CMMI. The aim of these standards is to make sure that the end product complies with market requirements and attains end-user satisfaction.

In fact, many software applications, mobile apps, and even full enterprise systems are sold to various customers every day that might not have been developed using any standard. The problem is not in following standards. What really matters is ignoring or diminishing the importance of the quality of the software. [4]

Let’s look into some specifics

1. 1. Requirements review

Reviewing the software requirements before starting each new development phase minimizes defects and fulfills clients' needs. Reviewing requirements before implementation helps in considering potential changes and overcoming misunderstandings that might occur throughout the project lifespan. The team has to double-check with the customer all business domain details that should be implemented. Requirements review can also be done using prototypes and domain models. When the development team does this small assignment before starting the actual implementation, they get excellent kick-off of their project or development iteration. By making sure that all stakeholders reach a consensus and every team player is on the same ground before rushing into implementation, the client and management are sure that the developers will deliver the right thing at the end of the development cycle.

1. 1. Code review and walkthrough

Code review is one of the most effective practices in software development. It has a direct impact on reducing the number of and enhancing the quality of the code and software design. This diminishes the need to do major code refactoring and clean-up in future releases.

The team can agree on simple coding and design guidelines according to the project requirements and implementation details. These guidelines should be shared among the team members, and whenever a new feature is developed, one or more team members should review the new code and search for any coding or design mistakes.

This practice helps the team in many ways, including enhancing code quality and design, minimizing defects, and preventing them. Also, it allows the whole team to gain insight into each other's work, eases handover, and increases team awareness about different software components and functions. The team collaborates to verify and validate the quality of the code and how the design was implemented. They get direct feedback from their peers. There is a double benefit here: The code quality increases, and the team awareness and project ownership do, too.

1. 1. Session-based testing

Session-based testing, a methodology developed by James Bach, means dividing the testing load into sessions, where each session has a mission (a clearly stated outcome desired from the testing session). Each session has a defined timeframe (from 20 to 40 minutes), and the tester should be uninterrupted while the testing session is conducted.

It's like putting the tester inside a testing bubble for a while and letting the tester focus on finding defects for a specific software feature or function. During the session, the testing is guided by a set of test cases, and the tester can do exploratory testing, as well. Thus, session-based testing is a mixture of a formal testing method and testing innovation, because it gives the tester room for exploration and intuition that can allow time and leeway to find unusual defects or mess around with the software to get more from it.

During the session, the tester should document the behavior of the software, take snapshots, and write down the behavior of the software under specific input and setup. After the session ends, the session transcript is discussed with the team leader or technical manager. From their discussion, they find out what is considered a normal behavior and what is not, and then defect reports are created, based on this discussion.

Figure 1 describes the session-based testing methodology briefly. For any new change in the software, different test sessions are planned, each with a specified goal and mission. During the testing session, the tester uses test cases or does exploratory testing or both. When the testing session ends, the defects found during the session are reported.

1. 1. Risk-based testing

Development teams usually have frequent releases for the same software, because a lot of changes — either major or minor — happen during the development process. An important QA practice is to thoroughly test the software after each major release. On the other hand, it is time-consuming and difficult to run a full regression test suite for the whole software for each release. However, it is unsafe to test only the changed features or cut down the test case suite awkwardly. A piece of code might solve a defect but break something else in the code.

The risk-based testing approach stands in the middle. Its basic idea is to sort the software features and failure modes in descending order, from the most important or riskiest to the nice-to-have features and simple risks (one of the tools to do this is FMEA: failure modes and effects analysis). When the tester has such list at hand when testing a new release under a tight schedule, the tester focuses the efforts to make sure that the newly introduced changes didn't break anything else. Then it's easy to make sure that the changes didn't break any of the most important features in the software and that none of the most severe risks occurred.

Outcome

Every company aims to fly high in the competitive IT market, and it takes the effort to make good software that people like. Unfortunately, sometimes stress from clients or inpatient management might lead teams to bypass software quality practices, and they could end up delivering a product that is below expectations. The poor quality of the software is noticed only when it fails.

Software quality assurance is a process that certifies a software application for its QUALITY during the whole software application development phase. Last year, we comprehended the latest software testing trends, which has helped our software testing industry in revamping our current testing strategies.[6]

1. 1. Measure the Importance of Quality
   2. Plan the QA Process
   3. Analyse Quality Benchmarks
   4. Adopt ‘Test Early Test Often’ Principle
   5. Merge QA & Development Efforts with DevOps
   6. Engage in Continuous Testing
   7. Utilize Ready-made Test Frameworks
   8. Create a Robust Testing Environment
   9. Deploy Automated Testing
   10. Choose the Right Test Automation Tool
   11. Report Bugs Effectively
   12. Become a QA Detective
   13. Check for the Available Resources
   14. Allocate Time Appropriately
   15. Ensure Management Transparency
   16. Update Yourself with Market Trends
   17. Share Knowledge Extensively
   18. Always Offer Feedback
   19. Get Prepared for the Challenges
   20. Hire Dedicated QA teams

Quality assurance has two things to take care of:

1. 1. 1. Deliver quality applications on time
      2. Deliver error-free quality applications on time

There is hardly any major difference in the above 2 things, but, all the above best practices will be followed just to achieve the above 2 things. Hence, in doing so, software quality assurance teams might face various challenges from the development teams, management teams, industry trends, etc. Thus, needless to say, QA teams have to be prepared for the unforeseen challenges.

Final Thoughts

In the year 2016, a lot of fluctuations in the software testing & QA industry occurred. This gives us a clear-cut vision that 2017 and coming years are going to be really challenging in terms of quality assurance processes. Let’s adopt the above QA best practices to prepare ourselves for the rock-solid techy year.

Capability Maturity Model Integration (CMMI) is a process level improvement training and appraisal program. Administered by the CMMI Institute, a subsidiary of ISACA, it was developed at Carnegie Mellon University (CMU). It is required by many United States Department of Defense (DoD) and U.S. Government contracts, especially in software development. CMU claims CMMI can be used to guide process improvement across a project, division, or an entire organization. CMMI defines the following maturity levels for processes: Initial, Managed, Defined, Quantitatively Managed, and Optimizing. Version 1.3 was published in 2010.

CMMI addresses three areas of interest:

Product and service development — CMMI for Development (CMMI-DEV), Service establishment, management, — CMMI for Services (CMMI-SVC), and Product and service acquisition — CMMI for Acquisition (CMMI-ACQ).