Software Process Models – Quick
Revision Notes
Waterfall Model
Mnemonic: "Really Dumb Ideas Take Off" (Requirements, Design, Implementation, Testing,
Operation & Maintenance)
Definition:
The Waterfall model is a linear and sequential software process model where each phase
must be completed before the next begins. Once done, no going back.
Phases:
1. Requirements Analysis & Specification – SRS document created
2. Design – Architecture defined in SDD
3. Implementation & Unit Testing – Modules coded and tested
4. Integration & System Testing – Full system tested together
5. Operation & Maintenance – Deployed and maintained
When to Use:
- Fixed, stable requirements
- Short projects
- Known tech/tools
- Resources are ready
Advantages:
+ Simple, easy to manage
+ Well-documented
+ Predictable time & cost
Disadvantages:
- Not flexible
- Late testing
- Not good for large/complex
Keywords: Linear, Sequential, SRS, Rigid, Fixed Requirements
RAD Model
Mnemonic: "Big Dogs Play Around Trees" (Business, Data, Process, Application, Testing)
Definition:
RAD is a rapid development model using component reuse, workshops, and automation
tools. Suitable when requirements are known and timelines are short.
Phases:
1. Business Modeling – Understand data flow in business
2. Data Modeling – Define entities and attributes
3. Process Modeling – Define data transformations
4. Application Generation – Automated tool-based coding
5. Testing & Turnover – Emphasis on reuse, test new modules
When to Use:
- Short (2–3 months) projects
- Well-known requirements
- Low technical risk
Advantages:
+ Fast development
+ Encourages reuse
+ Flexible to change
Disadvantages:
- Needs skilled designers
- Not for high-risk or big projects
Keywords: Component reuse, Automated tools, User feedback, Workshops
Spiral Model
Mnemonic: "Only Risky Developers Plan" (Objective Setting, Risk Assessment, Development,
Planning)
Definition:
Spiral Model combines prototyping with waterfall phases, emphasizing risk management
and repeated loops.
Phases per Spiral Loop:
1. Objective Setting – Set goals & alternatives
2. Risk Assessment – Analyze & reduce risk
3. Development & Validation – Build and test
4. Planning – Plan next phase
When to Use:
- High-risk, large projects
- Evolving requirements
- Complex systems
Advantages:
+ Strong risk handling
+ Flexible and iterative
+ Early prototypes
Disadvantages:
- Expensive
- Needs expert analysts
Keywords: Risk-driven, Iterative, Boehm, Prototyping, Large systems
V-Model
Mnemonic: "Big Smart Apps Matter" (Business Req, System Design, Architecture, Module ↔
Acceptance, System, Integration, Unit Test)
Definition:
An extension of waterfall, aligning development and testing stages in a “V” shape.
Verification Phases:
- Business Requirements ↔ Acceptance Testing
- System Design ↔ System Testing
- Architecture Design ↔ Integration Testing
- Module Design ↔ Unit Testing
When to Use:
- Clear requirements
- Medium projects
Advantages:
+ Early test planning
+ Easy tracking
Disadvantages:
- Rigid
- No prototypes
- Poor for big projects
Keywords: V-shape, Parallel Testing, Verification = Validation, Structured
Incremental Model
Mnemonic: "Really Dumb Tigers Iterate" (Requirements, Design, Testing, Implementation)
Definition:
System is built and delivered in parts (increments). Each adds functionality to previous
ones.
Phases:
1. Requirement Analysis – Break into modules
2. Design & Development – Each increment is developed
3. Testing – Individual + integrated testing
4. Implementation – Deliver each increment
When to Use:
- Large, long projects
- Need partial delivery
Advantages:
+ Early functionality
+ Flexible to change
Disadvantages:
- Needs planning
- Cost can rise
Keywords: Modular, Partial Delivery, Integration, Feedback-driven
Agile Model
Mnemonic: "Red Dogs Chase Tiny Daring Foxes" (Requirements, Design, Construction,
Testing, Deployment, Feedback)
Definition:
Agile is an iterative model focused on flexibility, customer collaboration, and fast delivery.
Phases:
1. Requirement Gathering
2. Design (UML/User Flow)
3. Construction (Iteration)
4. Testing
5. Deployment
6. Feedback
When to Use:
- Small/medium projects
- Frequent changes
- Skilled team
Advantages:
+ Adaptive
+ Frequent feedback
+ Fast delivery
Disadvantages:
- Needs constant communication
- Less documentation
Keywords: Iterative, Continuous delivery, Feedback, Scrum, XP
Scrum (Agile)
Mnemonic: "PSS – People Sprint Successfully" (Product Owner, Scrum Master, Scrum Team)
Definition:
Scrum divides work into 1–4 week sprints with defined roles and ceremonies.
Roles:
- Product Owner – Backlog management
- Scrum Master – Facilitator
- Scrum Team – Developers
Ceremonies:
- Sprint Planning
- Daily Standups
- Sprint Review & Retrospective
Keywords: Sprint, Backlog, Roles, Agile Method
XP (eXtreme Programming)
Mnemonic: "Please Don’t Code Terribly Carelessly" (Planning, Designing, Coding, Testing,
Closure)
Definition:
XP is a customer-focused agile method with test-first coding and short iterations.
Practices:
- User Stories
- Pair Programming
- Continuous Integration
- Test-Driven Development
Keywords: Agile, Short Cycles, Test-first, Pair Programming, Kent Beck
Iterative Model
Mnemonic: "Really Dumb Ideas Take Days Repeating" (Req, Design, Implementation,
Testing, Deployment, Review)
Definition:
Builds software in repeated cycles. Each iteration refines and improves based on feedback.
Phases:
1. Requirement Analysis
2. Design
3. Implementation
4. Testing
5. Deployment
6. Review
7. Maintenance
Keywords: Loop, Evolving Requirements, Parallel Dev, White-box/Black-box Testing
Big Bang Model
Mnemonic: "BIG = Begin In Guesswork" (Begin coding, Ignore planning, Gamble outcome)
Definition:
No planning, just development. Requirements may not even exist.
Use When:
- Very small, academic projects
Advantages:
+ Simple
+ Few resources
Disadvantages:
- High risk
- Not scalable
Keywords: No structure, Trial-and-error, Small projects
Prototype Model
Mnemonic: "Real Quick Build Ensures Rapid Finalization" (Requirement, Quick Design,
Build Prototype, Evaluation, Refinement, Final Product)
Definition:
Builds an early model (prototype) to understand customer needs before real development.
Phases:
1. Requirement Gathering
2. Quick Design
3. Build Prototype
4. Evaluate
5. Refine
6. Final Product
Keywords: Feedback-first, Trial build, Early validation, Risk reduction
Evolutionary Process Model
Mnemonic: "EPO = Evolve Product Overtime" (Enhance in Cycles, Plan for Evolving Needs,
Ongoing Improvements)
Definition:
Similar to Iterative model but focuses on building features by category (not functionality).
Example:
Cycle 1 – GUI, Cycle 2 – File Handling, Cycle 3 – Queries, etc.
Advantages:
+ Risk reduction
+ User feedback at every step
Disadvantages:
- Final product only after all cycles
- Requires strong version management
Keywords: Cyclical, Category-based, Evolution, Feedback
