Program Development Life Cycle — purpose, types, stages, analysis to maintenance

A development life cycle provides a structured framework for building software. It ensures:

• Clear project management with defined phases and milestones
• Quality control through systematic testing and review at each stage
• Risk reduction by identifying problems early
• Communication — shared vocabulary for developers, managers, and stakeholders
• Maintainability — documentation and structure support future changes

Without a life cycle, projects risk scope creep, missed requirements, poor quality, and unmaintainable code.

The syllabus covers three main models. Each suits different project contexts.

Waterfall — linear, sequential phases

Analysis → Design → Coding → Testing → Maintenance

• Complete each phase fully before moving to the next
• Documentation-heavy, rigid structure
• Benefits: Simple to understand and manage; clear milestones; good for well-understood, stable requirements
• Drawbacks: Inflexible — hard to go back; late testing finds expensive bugs; poor for changing requirements; working software only appears late

Iterative — repeated cycles (iterations) that refine the product

Iteration 1: Analysis → Design → Code → Test → Review
Iteration 2: Analysis → Design → Code → Test → Review
...

• Each iteration delivers a working increment
• Feedback from each cycle informs the next
• Benefits: Early working software; adapts to changing requirements; risks identified early; continuous integration of feedback
• Drawbacks: Requires more management overhead; can lead to scope creep without discipline; architecture may need refactoring

Rapid Application Development (RAD) — fast prototyping with heavy user involvement

Requirements → Prototype → User Feedback → Refine → Deliver

• Emphasises prototypes over detailed upfront specs
• Time-boxed iterations (often 60-90 days total)
• Benefits: Very fast delivery; high user involvement; adapts quickly to feedback; good for UI-heavy systems
• Drawbacks: Requires skilled, committed team; not suitable for safety-critical or large-scale systems; can sacrifice quality for speed; difficult to scale

These stages appear in all models (though order and overlap vary).

1. Analysis — What must the system do?

• Gather requirements from stakeholders (interviews, observation, documents)
• Produce requirements specification — functional & non-functional needs
• Feasibility study (technical, economic, legal, operational, schedule)
• Define system boundaries and constraints

2. Design — How will the system work?

• Architectural design: overall structure, modules, interfaces, data flow
• Detailed design: algorithms, data structures, database schema, UI mockups
• Structure charts, flowcharts, pseudocode, ER diagrams, state-transition diagrams
• Design specification document

3. Coding (Implementation) — Writing the program

• Translate design into source code (following coding standards)
• Use appropriate language features, libraries, and tools
• Code reviews, version control, continuous integration
• Produce executable modules

4. Testing — Does it work correctly?

• Unit testing: individual modules/functions
• Integration testing: modules working together
• System testing: whole system against requirements
• Acceptance testing: user validates it meets needs
• Test plans, test cases, test data (normal, abnormal, boundary)
• Debug and fix defects

5. Maintenance — Keep it working after delivery

• Corrective: fix bugs found in use
• Adaptive: modify for new environment (OS, hardware, regulations)
• Perfective: enhance performance, add features, improve usability
• Ongoing: monitoring, patches, updates, documentation updates