Unit 6: Quality Management, Maintenance & Emerging Technologies

1. Quality Management & Standards

Software Quality Management (SQM) is an umbrella activity that is applied throughout the software process. It involves specific activities that aim to ensure that the software products are fit for use and meet the required standards.

1.1 ISO 9001 (Quality Management System)

ISO 9000 is a family of standards, with ISO 9001 being the specific standard used for certification in software organizations. It is generic and applies to any industry, focusing on process management rather than product quality directly.

• Key Principles:

  • Customer Focus: Understanding current and future customer needs.
  • Leadership: Leaders establish unity of purpose and direction.
  • Engagement of People: Full involvement of employees enables their abilities to be used for the organization's benefit.
  • Process Approach: Managing activities and resources as a process.
  • Continuous Improvement: A permanent objective of the organization.
  • Evidence-based Decision Making: Decisions based on the analysis of data and information.

• ISO 9001:2015 Structure: Requires organizations to define a Quality Management System (QMS), document processes, and audit them regularly to ensure compliance.

1.2 SEI CMMI (Capability Maturity Model Integration)

Developed by the Software Engineering Institute (SEI), CMMI is a process improvement approach that provides organizations with the essential elements of effective processes. It measures the maturity of the software development process on a scale from 1 to 5.

The 5 Levels of CMMI:

1. Initial (Ad hoc/Chaotic): Processes are unpredictable, poorly controlled, and reactive. Success depends on individual heroics rather than a stable process.
2. Managed: Processes are characterized for projects and are often reactive. Basic project management (tracking cost, schedule, and functionality) is established.
3. Defined: Processes are characterized for the organization and are proactive. Standard processes, procedures, and tools are defined at the organizational level.
4. Quantitatively Managed: Processes are measured and controlled. The organization uses quantitative data to understand process performance and manage project outcomes.
5. Optimizing: Focus on continuous process improvement. The organization focuses on constantly improving process performance through incremental and innovative technological improvements.

1.3 Six Sigma

Six Sigma is a data-driven methodology for eliminating defects (driving toward six standard deviations between the mean and the nearest specification limit) in any process.

• Goal: To achieve 3.4 defects per million opportunities (DPMO).
• Methodology (DMAIC): Used for improving existing processes.
  • Define: Define the problem and project goals.
  • Measure: Measure key aspects of the current process and collect relevant data.
  • Analyze: Analyze the data to investigate and verify cause-and-effect relationships.
  • Improve: Optimize the current process based on data analysis.
  • Control: Control the future state processes to ensure that any deviations are corrected before they result in defects.

1.4 PSP (Personal Software Process)

Developed by Watts Humphrey, PSP is a structured software development process that is intended to help software engineers understand and improve their own performance.

• Objective: To bring discipline to individual engineers.
• Key Framework Elements:
  • Time Management: Logging time spent on each phase (planning, coding, compiling, testing).
  • Defect Management: Logging every defect found, its type, and the time taken to fix it.
  • Estimation: Using historical data to estimate the size and time required for new tasks.
• Process Levels:
  • PSP0: Baseline process (current coding style).
  • PSP1: Personal planning (size and resource estimation).
  • PSP2: Personal quality management (code reviews and design reviews).
  • PSP3: Cyclic process (for larger programs).

2. Computer-Aided Software Engineering (CASE Tools)

CASE tools are software applications used to automate part or all of the software development life cycle (SDLC). They provide an environment for the development team to create, manage, and maintain software projects with high quality.

Categories of CASE Tools

1. Upper CASE Tools: Support the planning, analysis, and design phases.
   • Examples: Requirement analysis tools, Diagramming tools (e.g., Visio, StarUML).
2. Lower CASE Tools: Support the implementation, testing, and maintenance phases.
   • Examples: Code generators, Debuggers, Static Analysis tools.
3. Integrated CASE (I-CASE): Support the entire SDLC, integrating Upper and Lower CASE tools into a seamless environment.

Common Types and Examples

• Diagramming Tools: Draw UML diagrams, flowcharts (e.g., Lucidchart).
• Project Management Tools: Schedule and tracking (e.g., Jira, Trello).
• Documentation Tools: Generate technical docs (e.g., Doxygen, Javadoc).
• Version Control Tools: Manage code changes (e.g., Git, SVN).
• Testing Tools: Automate testing (e.g., Selenium, JUnit).

3. Software Maintenance

Software maintenance is the process of modifying a software system or component after delivery to correct faults, improve performance, or adapt to a changed environment. It is often the longest and most costly phase of the SDLC (consuming 60-80% of total lifecycle costs).

3.1 Types of Maintenance

1. Corrective Maintenance (approx. 20%):
   • Reactive modification to correct discovered problems (bugs/defects) after delivery.
2. Adaptive Maintenance (approx. 25%):
   • Modification to keep the software usable in a changed or changing environment (e.g., OS upgrades, hardware changes, new compliance rules).
3. Perfective Maintenance (approx. 50%):
   • Modification to improve performance or maintainability (e.g., making the system faster, improving the GUI). This is driven by user requests for enhancements.
4. Preventive Maintenance (approx. 5%):
   • Modification to detect and correct latent faults in the software product before they become effective faults (e.g., code refactoring, updating documentation).

3.2 Challenges in Maintenance

• Legacy Code: dealing with unstructured "spaghetti code" written in obsolete languages.
• Lack of Documentation: Original developers may have left; documentation is often missing or outdated.
• Ripple Effect: Changes in one part of the system may inadvertently break other parts (regression).
• High Staff Turnover: Maintenance is often viewed as less glamorous than new development, leading to motivation issues.
• Cost Estimation: It is extremely difficult to estimate the cost and time required to fix a bug in an unfamiliar system.

4. Software Reuse & Component-Based Software Development (CBSD)

4.1 Software Reuse

The use of existing software artifacts (code, designs, requirements, test cases) to build new software.

• Benefits: Increased reliability (reused code is already tested), reduced development cost, faster time-to-market.
• Levels of Reuse:
  • Abstraction Level: Design patterns, architectural patterns.
  • Object Level: Reusing classes or libraries.
  • Component Level: Reusing subsystems or COTS (Commercial Off-The-Shelf) components.

4.2 Component-Based Software Development (CBSD)

CBSD focuses on building large software systems by integrating pre-existing software components.

Characteristics of a Component:

1. Independent: Ideally, a component has minimal dependencies.
2. Standardized Interface: Components communicate via well-defined interfaces (APIs). The internals are hidden (Black Box).
3. Deployable: It is a binary unit of composition.

CBSD Lifecycle:

1. Component Qualification: Evaluating available components to see if they match requirements.
2. Component Adaptation: Modifying the component (via wrappers or configuration) to fit the architecture.
3. Component Composition: Integrating the components into the system.
4. Component Update: Replacing old components with newer versions.

5. Advanced and Future Techniques

5.1 Cloud-Native Software Development

An approach to building and running applications that exploits the advantages of the cloud computing delivery model.

• Microservices: Breaking monolithic applications into small, loosely coupled services that can be deployed independently.
• Containers (Docker/Kubernetes): Packaging software with its dependencies to ensure it runs consistently across any environment.
• DevOps & CI/CD: Continuous Integration and Continuous Deployment pipelines automate the testing and release process.
• Serverless: Developers write code (Functions as a Service) without managing the underlying infrastructure (e.g., AWS Lambda).

5.2 AI in Software Development (AI-Augmented Engineering)

Artificial Intelligence is transforming how code is written, tested, and maintained.

• Tools:
  • GitHub Copilot: Powered by OpenAI Codex. It functions as an "AI Pair Programmer," suggesting whole lines or functions of code inside the IDE based on comments and context.
  • Amazon CodeWhisperer: Similar to Copilot but optimized for AWS ecosystems and security scanning.
• Capabilities:
  • Code Generation: Translating natural language comments into executable code.
  • Test Case Generation: Automatically creating unit tests for existing functions.
  • Code Translation: Converting legacy code (e.g., COBOL) to modern languages (e.g., Java).
  • Bug Detection: Analyzing patterns to predict likely bugs before compilation.
• Challenges:
  • Copyright/Legal: AI models are trained on public code; ownership of generated code is debated.
  • Security: AI might suggest insecure coding patterns if trained on vulnerable data.

5.3 Low-Code / No-Code Platforms

These platforms democratize software creation, allowing non-technical users to build applications.

• No-Code:
  • Target: "Citizen Developers" (business users with no coding knowledge).
  • Mechanism: Drag-and-drop interfaces, visual logic builders.
  • Use Cases: Simple internal tools, forms, landing pages.
  • Examples: Bubble, Webflow, Airtable.
• Low-Code:
  • Target: Professional developers (to speed up work) and technical business users.
  • Mechanism: Visual IDEs with the ability to inject custom code (scripting) when necessary.
  • Use Cases: Enterprise resource planning (ERP) extensions, rapid prototyping, complex workflows.
  • Examples: Mendix, OutSystems, Microsoft PowerApps.
• Benefits: Drastically reduced development time, lower cost, bridges the gap between IT and business teams.
• Risks: Vendor lock-in, "Shadow IT" (unmanaged apps), scalability limitations.