Ch2 SW Processes - Tagged
Chapter 2 - Software Processes
Introduction
Software processes are structured sets of activities required to develop a software system.
Different software processes exist, all involving:
Specification: Defining what the system should do.
Design and Implementation: Organizing the system and implementing it.
Validation: Ensuring the system meets customer requirements.
Evolution: Adapting the system to changing customer needs.
A software process model is an abstract representation, providing a description from a specific perspective.
Software Process Models
Various software process models include:
Waterfall Model: A plan-driven model with distinct phases of specification and development.
Incremental Development: Specification, development, and validation are interleaved; can be plan-driven or agile.
Integration and Configuration: Assembling systems from existing configurable components; may also be plan-driven or agile.
Waterfall Model
Phases of the Waterfall Model:
Requirements Analysis and Definition
System and Software Design
Implementation and Unit Testing
Integration and System Testing
Operation and Maintenance
Problems with Waterfall Model:
Inflexibility: Difficult to accommodate changes after the process starts, suitable mainly for stable requirements.
Most applicable in large systems engineering projects.
Incremental Development
Benefits:
Reduces costs relating to accommodating changes.
Easier customer feedback on developments via functional demonstrations.
Potential for quicker delivery of useful software.
Problems:
Visibility issues for managers due to rapid development cycles.
Risk of degrading system structure from regular incremental changes without refactoring.
Integration and Configuration
Emphasizes software reuse by integrating existing components.
Types of Reusable Software:
Stand-alone application systems (COTS).
Object collections integrated within frameworks (like .NET or J2EE).
Web services developed under service standards.
Process Activities
Basic Activities:
Specification
Development
Validation
Evolution
Organization of activities varies across processes, e.g. sequential in waterfall versus interleaved in incremental development.
Requirements Engineering Process
Requirements Elicitation and Analysis
Requirements Specification
Requirements Validation
Software Design and Implementation
Design: Creating a structure that adheres to specifications.
Implementation: Translating this structure into executable programs.
Activities can be interleaved.
Software Validation
Verification and Validation (V&V) ensure conformity to specifications and customer needs.
Includes:
Checking and Review Processes
System Testing with real data test cases.
Stages of Testing
Component Testing: Testing individual components.
System Testing: Testing the whole system; focusing on emergent properties.
Customer Testing: Validating the system with customer-provided data.
Software Evolution
Software is inherently flexible and must adapt with changing requirements.
Evolution integrates with ongoing development and maintenance cycles.
Coping with Change
Strategies:
Change anticipation: Planning for potential changes, e.g., through prototyping.
Change tolerance: Designing processes to easily accommodate changes, often through incremental development.
Prototyping
Prototypes are early versions to demonstrate concepts and evaluate design options.
Benefits:
Improved usability and design quality.
Better alignment with user needs and reduced development effort.
Incremental Delivery
Supports customer feedback by breaking project delivery into increments, where higher priority features are addressed first.
Helps manage project risks and enhances software usability ratings.
Process Improvement
Focus:
Enhancing software quality, reducing costs, and accelerating development.
Key Processes for Improvement:
Process Measurement: Attributes assessed for effective evaluation.
Process Analysis: Identifying weaknesses in current processes.
Process Change: Proposing changes for improvement.
Capability Maturity Model
Five levels:
Initial
Managed
Defined
Quantitatively Managed
Optimizing
Key Points
Software processes comprise activities involved in producing software systems.
General models include waterfall, incremental, and reuse-oriented development.
The processes include software specification, design, validation, evolution, and adaptation to change.
Chapter 2 - Software Processes
Introduction
Software processes are structured sets of activities required to develop a software system effectively. These processes not only define the sequence of activities necessary for software development but also outline the interdependencies among these activities. Different software processes exist, all involving four core components:
Specification: This stage involves defining what the system should accomplish, including the functional and non-functional requirements that reflect the needs and expectations of the stakeholders.
Design and Implementation: Once the specifications are clear, this phase includes designing the architecture and components of the system. It focuses on organizing all parts of the software, leading to the actual coding and development, transforming design documents into executable programs.
Validation: Validation ensures the developed system meets the intended requirements through various testing strategies. This includes confirming that the software operates as expected in practical conditions.
Evolution: As user requirements change or technology advances, the software needs to evolve. This involves updating the system to accommodate new functionalities, fixing bugs, and improving performance based on user feedback.
A software process model serves as an abstract representation, offering a framework or description of the software development process from a specific perspective, guiding teams in navigating the complexities of software projects.
Software Process Models
Various software process models provide frameworks for organizing software development tasks:
Waterfall Model: A traditional, plan-driven model comprising distinct and sequential phases of specification, development, and maintenance. This model emphasizes documentation and structure, making it suitable for projects with well-defined requirements from the outset.
Incremental Development: This model allows for overlapping phases of specification, development, and validation. Both plan-driven and agile methodologies can be utilized. By breaking the process into smaller increments, this approach enables the development of functional components early and encourages client feedback.
Integration and Configuration: This model emphasizes software reuse by integrating existing software components rather than building new systems from scratch. It includes configurable components, such as commercial off-the-shelf software (COTS), object collections within frameworks, and web services that adhere to service standards. Both plan-driven and agile approaches can be applied.
Waterfall Model
Phases of the Waterfall Model:
Requirements Analysis and Definition: Gathering and documenting what the stakeholders require from the system.
System and Software Design: Creating blueprints for the implementation of the system.
Implementation and Unit Testing: Writing code and unit testing for individual components to ensure they function correctly.
Integration and System Testing: Combining all components and testing the entire system in an environment that mimics the production environment.
Operation and Maintenance: Deploying the system into the operational environment and performing necessary maintenance tasks.
Problems with Waterfall Model:
Inflexibility: Changes in requirements are challenging to implement once the process has advanced, making this model more suitable for projects with stable requirements.
Large Projects: It is most applicable in large systems engineering projects where requirements are well understood and less likely to change significantly during the development process.
Incremental Development
Benefits:
Cost Efficiency: Reduces costs associated with changes since modifications can be made in future increments rather than requiring a complete redesign.
Customer Feedback: Stakeholders can provide feedback on each increment, enhancing the alignment of the final product with their expectations.
Rapid Delivery: This model allows for faster delivery of functional software, with usable features released early in the development cycle.
Problems:
Visibility Issues: Rapid development cycles can create difficulties for managers to track overall project status and progress.
Degrading System Structure: Frequent incremental changes without proper refactoring can lead to a decline in system architecture and performance over time.
Integration and Configuration
This approach focuses on leveraging existing software components, promoting software reuse and efficiency.
Types of Reusable Software:
Stand-alone application systems (COTS): Commercial software products that can be customized to meet specific user needs.
Object Collections in Frameworks: Software components that can be integrated into broader systems (e.g., .NET, J2EE frameworks).
Web Services: Software functionalities available over the Internet that adhere to defined service standards, facilitating integration with other applications.
Process Activities
Basic Activities:
Specification: Clearly defining system requirements and expectations.
Development: Actual coding and creation of the software.
Validation: Ensuring that the developed software meets the specified requirements and functions as intended.
Evolution: Continuously updating the software to meet changing needs.
The organization of these activities varies across processes. For instance, the waterfall model is sequential, while incremental development interleaves activities.
Requirements Engineering Process
Requirements Elicitation and Analysis: Collaborating with stakeholders to gather informative requirements through interviews, surveys, or workshops.
Requirements Specification: Documenting requirements in a structured and accessible format for stakeholders and developers.
Requirements Validation: Ensuring that the specified requirements are feasible, clear, complete, and testable.
Software Design and Implementation
Design: Creating a detailed structural representation of the software that aligns with specified requirements.
Implementation: Converting design artifacts into executable code. This is an iterative process where development and design can occur concurrently.
Software Validation
Verification and Validation (V&V) processes confirm that the software meets specifications and customer requirements. These processes involve:
Checking and Review Processes: Regular reviews of documentation and code to ensure alignment with requirements.
System Testing with Real Data Test Cases: Testing the software using actual data to verify functionality and performance under realistic conditions.
Stages of Testing
Component Testing: Testing individual modules or components to uncover issues at the smallest unit level.
System Testing: Testing the entire system for compliance with specified requirements and to verify that all components work together seamlessly.
Customer Testing: Validating the system using data provided by end-users, ensuring that it meets their needs satisfactorily.
Software Evolution
Software is subject to continual change and must be able to adapt to evolving requirements. This process of evolution is integrated with ongoing development and maintenance activities.
Coping with Change
Strategies:
Change Anticipation: Involves planning for possible changes early in the development process, often through prototyping.
Change Tolerance: Designing processes and systems that accommodate changes fluidly, maximizing responsiveness through incremental development.
Prototyping
Prototypes are preliminary models of the final product, demonstrating concepts and allowing for early feedback and design evaluation.
Benefits:
Enhanced usability and quality of the design based on early testing and feedback.
Improved alignment with user requirements, leading to reduced effort in the later stages of development.
Incremental Delivery
This strategy, which involves delivering the project in parts (increments), supports ongoing customer feedback. It prioritizes high-value features to be developed and delivered first, making it a risk management tool that can lead to higher software usability ratings.
Process Improvement
The focus of process improvement is on enhancing software quality, reducing costs, and accelerating the development timeline.
Key Processes for Improvement:
Process Measurement: Identifying attributes that can be assessed for effective evaluation.
Process Analysis: Evaluating current processes to identify areas for improvement and weaknesses.
Process Change: Implementing changes based on analysis to enhance overall effectiveness and efficiency.
Capability Maturity Model
This model outlines five levels of process maturity:
Initial: Processes are unpredictable, poorly controlled, and reactive.
Managed: Processes are planned and executed in accordance with policy.
Defined: Processes are documented, standardized, and integrated into a coherent whole.
Quantitatively Managed: Processes are controlled using statistical and other quantitative techniques.
Optimizing: Focus is on continuous improvement of processes through incremental and innovative technological improvements.
Key Points
Software processes consist of the essential activities involved in developing software systems.
Common process models include waterfall, incremental, and reuse-oriented development approaches.
Major activities covered by these processes include software specification, design, validation, evolution, along with strategies for adapting to change.