📚 Software Process Models
Brief Overview
This note covers Software Process Models and was created from an uploaded document.
It includes waterfall, incremental, COTS, hybrid models, and the full software development
lifecycle.
Key Points
Waterfall: sequential phases with clear milestones but limited flexibility.
Incremental: iterative delivery, early feedback, reduced change cost.
COTS: reuse of configurable components, lower cost, possible requirement
trade‑offs.
📋 Software Process Overview
Software process – a structured set of activities required to develop a software
system.
Specification – defining what the system should do.
Design & implementation – organizing the system and turning the design into
executable code.
Validation – checking that the system meets customer needs.
Evolution – adapting the system as requirements change.
A software process model is an abstract representation of a process, describing
activities, their ordering, and often the associated products, roles, and
pre/post‑conditions.
🏞️ Software Process Models
Model Core Idea Typical Use Key Key
Advantages Disadvantages
Waterfall 🌊 Sequential, Large, Strong
coordination,
Rigid; hard to
accommodate
plan‑driven well‑understood
phases (spec → projects, changes
design → impl → multi‑site clear
test → engineering milestones
maintain)
Incremental Interleaved Projects Reduced cost Process not
Development specification, needing early of changes, always visible;
📈 development,
validation in
feedback,
evolving
faster delivery,
frequent
system
structure may
repeated requirements customer degrade over
increments feedback time
Assemble & Build system When reusable Lower cost, Possible
Configure from existing off‑the‑shelf quicker requirement
(COTS) 🧩 configurable
components
products are delivery compromises,
loss of control
available
over
component
evolution
Hybrid ⚙️ Mix of the
above
Real‑world Flexibility to
leverage
Requires
careful
projects
approaches combining strengths of management
custom and each model to avoid
COTS elements complexity
🔄 Process Activities
Process activities – the inter‑leaved technical, collaborative, and managerial tasks that
achieve specification, design, implementation, and testing.
Specification – define services and constraints (see Requirements
Engineering).
Development – design and code the system (often interleaved).
Validation – verify conformity to specifications (testing, reviews).
Evolution – modify the system in response to new needs.
📐 Software Specification & Requirements Engineering
Requirements Engineering – the discipline of discovering, analyzing, documenting,
and validating system requirements.
Key steps (illustrated in the flowchart below):
1. Requirements Elicitation & Analysis – gather stakeholder expectations.
2. Requirements Specification – produce a detailed, unambiguous description.
3. Requirements Validation – ensure requirements are correct and feasible.
4. System Descriptions – translate requirements into system‑level artifacts.
5. User & System Requirements – differentiate between what users need and
what the system must provide.
6. Requirements Document – compile all artifacts into a formal specification.
The diagram shows the six main components of the requirements engineering workflow
and how information flows between them.
🏗️ Software Design & Implementation
Software design – creation of a structure that realizes the specification.
Implementation – translation of the design into executable code.
Design Activities
Architectural design – overall system structure and main subsystems.
Database design – data models, tables, and relationships.
Interface design – UI for humans or APIs for components.
Component selection & design – decide between COTS components or
custom‑built modules.
Implementation Highlights
Writing code against the design (programming).
Debugging – locating and fixing faults.
Design and implementation are often interleaved.
This flowchart outlines inputs (platform info, requirements, data description) leading
through architectural, interface, component, and database design to final specifications.
✅ Software Validation & Testing
Verification & Validation (V&V) – activities that show software conforms to its
specification and meets customer needs.
Verification – checking the product is built correctly (reviews, inspections).
Validation – ensuring the right product is built (testing).
Testing Stages
Stage Focus
Component testing Individual functions, classes, or modules.
System testing Whole system behavior, emergent
properties.
Customer testing Real‑world data to confirm the system
satisfies user needs.
Testing is the most common V&V activity and involves executing the software with
representative test cases.
🔧 Software Evolution & Coping with Change
Change is inevitable – driven by business shifts, new technologies, or platform
updates.
Costs include re‑analysis of requirements and implementation of new
functionality.
Strategies for Managing Change
1. Prototyping – quick, partial implementations to validate concepts.
2. Incremental delivery – provide functional increments for early feedback.
🛠️ Prototyping
Prototype – an initial version of software used to demonstrate concepts and explore
design options.
Uses
Aid requirements elicitation and validation.
Explore UI or design alternatives.
Conduct early testing (back‑to‑back tests).
Benefits
Improved usability and closer alignment with user needs.
Reduced overall development effort.
Prototype Development Process
1. Establish prototype objectives → Prototyping plan
2. Define prototype functionality → Outline definition
3. Develop prototype → Executable prototype
4. Evaluate prototype → Evaluation report
The flowchart details the structured approach to creating a prototype, from objectives to
evaluation.
Throw‑away Prototypes
Intended for discard after use.
May contain non‑standard code or prioritize speed over maintainability.
Useful when requirements are unstable.
📈 Incremental Development & Delivery
Incremental development – the system is built as a series of increments, each adding
functionality and undergoing validation before the next begins.
Process Overview (see flowchart):
1. Define outline requirements → assign to increments.
2. Design system architecture for the increment.
3. Develop the increment.
4. Integrate the increment with existing system parts.
5. Validate the increment.
6. Deploy the increment.
7. Repeat until the complete system is delivered.
This diagram shows the cyclical nature of incremental development, emphasizing repeated
design, build, integrate, validate, and deploy steps.
Advantages
Lower cost for accommodating changes.
Early customer feedback and faster delivery of usable software.
Challenges
Process visibility can be limited for managers.
System architecture may degrade as new increments are layered.
🧩 Assemble & Configure (COTS) – Integration &
Configuration (I & C)
I & C – reuse‑oriented engineering that assembles existing components to meet system
requirements.
Pros
Reduced development cost and risk.
Faster time‑to‑market.
Cons
Potential compromises on requirements.
Limited control over future evolution of reused elements.
The flowchart outlines the steps for modifying a system: define requirements → assess
existing system → propose changes → modify system.