Scribd
Upload
3 views

OOSE_SQA_and_Software_Reuse_Lecture

Uploaded by

yasiniqbal302
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
3 views

OOSE_SQA_and_Software_Reuse_Lecture

Uploaded by

yasiniqbal302
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

Software Quality Assurance and

Software Reuse
Introduction:
In this lecture, we will explore two crucial aspects of modern software engineering:
software quality assurance (SQA) and software reuse. Both are fundamental to delivering
high-quality, reliable, and cost-effective software systems.

1. Software Quality Assurance (SQA)

Definition:
Software Quality Assurance is a set of activities designed to ensure that the software
development process and its outcomes meet specified quality standards. The focus is on
the prevention of defects and the continuous improvement of processes to maintain
software quality.

Key Principles of SQA:


• Process Focus: SQA emphasizes improving processes to prevent defects, not just
identifying them.
• Continuous Improvement: It's not a one-time activity but an ongoing process to
enhance software quality.
• Verification and Validation: These are critical activities in ensuring that the product is
both built correctly and satisfies user needs.

Quality Standards
Standards like ISO/IEC 25010 define quality models with characteristics such as:
• Functionality: Does the software deliver the required functionality?
• Reliability: How well does the software perform under various conditions?
• Usability: Is the software easy to use and understand?
• Efficiency: Is the system optimized in terms of performance and resource usage?
• Maintainability: How easy is it to correct or modify the software?
• Portability: Can the software be easily transferred to different environments?
SQA Activities:
• Reviews and Inspections:
Example: Code inspections or peer reviews where the team checks for potential
defects or design flaws.

• Static Analysis Tools:


Example: Tools like SonarQube for automatically scanning code to find security
vulnerabilities or performance bottlenecks.

• Testing (Dynamic Verification):


Example: Unit testing (testing individual components), integration testing (ensuring
different modules work together), and system testing.
• Process Audits:
Example: Periodic audits to verify that the team follows the established development and
quality processes.

Example Case Study:


Consider a company developing a flight control system for an airline. SQA processes like
reviews, inspections, and comprehensive testing are crucial since any software defect
could result in significant safety hazards. The company would adopt rigorous quality
standards like DO-178C, which provides guidelines for airborne software.

The Role of SQA in Agile Development:


In agile processes, SQA practices are embedded throughout the development lifecycle.
Continuous integration (CI) and continuous testing ensure that quality is maintained with
each iteration.

Example in Agile:
In a Scrum team, each sprint includes not only feature development but also testing and
peer reviews. Automated unit tests are run with each code commit to identify regressions
early.

2. Software Reuse

Definition:
Software reuse refers to the practice of using existing software components, designs, or
systems in the creation of new software. This not only accelerates development but also
enhances reliability since reused components are often well-tested.
Levels of Reuse:
• System Reuse: Reusing entire systems with minor modifications.
Example: Enterprise resource planning (ERP) systems like SAP or Oracle are
reused across different industries with slight customizations.
• Component Reuse: Reusing software components such as libraries or frameworks.
Example: Reusing authentication modules from a pre-built library like OAuth in
multiple applications.
• Object and Function Reuse: Reusing specific functions or classes.
Example: Reusing a logging function or a mathematical utility class in multiple
projects.

Software Reuse Benefits:


• Reduced Development Time: Ready-made components reduce the need for
developing from scratch.
• Increased Reliability: Reused components are typically well-tested, leading to fewer
defects.
• Cost Savings: Reduced development effort and testing leads to cost reductions.
• Enhanced Maintainability: Reused components often come with documentation and
support, making future maintenance easier.

Challenges in Reuse:
• Finding Reusable Components: It can be difficult to locate components that exactly
match project needs.
• Integration Issues: Combining reused components with new systems can lead to
compatibility issues.
• Licensing and Legal Issues: Some components may come with restrictive licenses,
limiting their reuse.

Reuse in Software Product Lines (SPL):


A more structured approach to reuse is seen in Software Product Lines (SPL), where a
family of products is built around a core set of shared features. By planning for reuse
from the beginning, companies can systematically produce related products with minimal
development effort.

Example of SPL:
Automotive software systems often use SPLs. Car manufacturers might have a product
line for the infotainment system, where the core functionality is shared across models but
customized for each vehicle’s requirements. This structured reuse saves time and ensures
consistency across products.
Design Patterns and Reuse:
Design patterns are another important aspect of reuse. These are generalized, reusable
solutions to common problems in software design.

Example:
The Singleton Pattern ensures a class has only one instance and provides a global point of
access to it.
Real-world Example: A database connection pool implemented as a Singleton to ensure
only one connection pool is created throughout the application.

Open Source and Component Reuse:


The rise of open-source software has greatly facilitated software reuse. Many developers
rely on open-source libraries like jQuery (for web development) or TensorFlow (for
machine learning), which allow them to focus on higher-level logic rather than
reinventing core functionality.

Key Takeaways:
1. Software Quality Assurance is essential for ensuring that both the process and
product meet desired standards. It involves a variety of techniques, from reviews
and static analysis to testing and audits.

2. Software Reuse promotes efficiency and reliability by leveraging existing


software components, designs, and systems. However, it comes with its own set of
challenges, such as integration and licensing issues.

By combining strong SQA practices with strategic software reuse, organizations can
not only produce higher-quality software but also reduce development time and cost.

Discussion Points:
1. Can you think of a project where you could have benefitted from reusing software
components?
2. What challenges do you anticipate when trying to introduce software quality assurance
practices in an agile team setting?

You might also like