Show understanding of the purpose of a development life cycle

Program Development Life Cycle (PDLC) – Purpose & Benefits

Learning Objective

Explain why a development life‑cycle is used and how it helps produce reliable, maintainable software that meets the needs of all stakeholders.

Why Use a Development Life Cycle?

• Structure & repeatability – Provides a clear, ordered set of activities that can be followed for any project.
• Complete requirements capture – Ensures functional and non‑functional requirements are recorded, reviewed and verified.
• Realistic planning – Supports estimation of time, cost and resources; aids budgeting and scheduling.
• Risk reduction – Early feasibility studies and regular testing identify problems before they become expensive to fix.
• Improved communication – Gives developers, users, managers and other stakeholders a common language and set of artefacts.
• Maintainability – Documentation and modular design created during the cycle make future changes easier.

Typical Stages of the PDLC (Cambridge Syllabus)

1. Planning & Feasibility Study

   • Define the problem, objectives and success criteria.
   • Analyse technical, economic, legal and ethical feasibility.
   • Produce a brief Project Brief (scope, constraints, stakeholders).

2. Requirements Analysis

   • Gather functional requirements (what the system must do).
   • Gather non‑functional requirements (performance, security, usability, reliability).
   • Document using use cases, user stories or a functional specification.

3. System Design

   • High‑level (architectural) design – Choose architecture (e.g., three‑tier, client‑server), define modules and interfaces.
   • Detailed design – Specify algorithms, data structures, pseudo‑code, database schema and UI mock‑ups.
   • Produce design artefacts: flowcharts, ER diagrams, class diagrams, data dictionaries.

4. Implementation (Coding)

   • Translate detailed design into source code using an appropriate language.
   • Follow coding standards, add meaningful comments and use a version‑control system (e.g., Git).

5. Testing

   • Unit testing – Verify each module/function works in isolation.
   • Integration testing – Check interactions between modules.
   • System testing – Validate the complete system against the requirements specification.
   • User Acceptance Testing (UAT) – Confirm the solution meets the user’s needs.

6. Deployment

   • Install the software in the target environment (server, cloud, mobile device, etc.).
   • Provide user training, help files and technical documentation.

7. Maintenance

   • Correct defects, improve performance, and add new features.
   • Manage configuration, version control and regular backups.
   • Document changes (change log, revised user manuals).

Common Development Models

Linear vs. Iterative Models – Quick Comparison

Illustrative Example – Simple Inventory Management System

1. Planning – System must track stock levels, generate reports and support multiple users.
2. Requirements – Add/remove items, alert when stock < 5, export CSV, secure login.
3. Design

   • Three‑tier architecture (Presentation, Business Logic, Database).
   • ER diagram with Item, User, Transaction tables.
   • Algorithm for stock‑level check (pseudo‑code shown below).

   FOR each transaction DO
   UPDATE Item.stock = Item.stock – transaction.quantity
   IF Item.stock < 5 THEN
   SEND alert TO manager
   END IF
   END FOR
   

4. Implementation – Python (Flask) for web UI, SQLite for storage, CSS for styling.
5. Testing

   • Unit tests with pytest for each function.
   • Integration tests of REST API endpoints.
   • UAT with shop owner – confirm reports and alerts work as expected.

6. Deployment – Host on a local Linux server; provide a PDF user manual and a short video tutorial.
7. Maintenance – Six months later add “Supplier Order” feature and refactor the database to support multiple warehouses.

Effort Estimation (Mathematical Insight)

Cambridge A‑Level often expects an awareness of simple estimation techniques such as COCOMO:

\$\$

E = a \times (\text{KLOC})^{b}

\$\$

• a and b depend on project type (organic, semi‑detached, embedded).
• KLOC = estimated thousands of lines of code.

Exam‑Style Tips

• When asked to “show understanding of the purpose of a development life cycle”, mention at least three of the benefits listed above and link each benefit to a specific stage.
• For diagram questions, label the stages in order and include key artefacts (e.g., requirements specification, design diagram, test plan).
• If a model is specified, compare it with another model using a two‑column table – focus on flexibility, risk, documentation and stakeholder involvement.
• Use real‑world examples (e.g., mobile app, school timetable system) to illustrate each stage; keep the example concise but complete.

Summary

A development life cycle provides a systematic framework that turns an abstract problem into a working, maintainable software solution. By progressing through the stages of planning, analysis, design, implementation, testing, deployment and maintenance, developers can:

• Capture all required functionality and quality attributes.
• Plan resources accurately and manage risks early.
• Communicate clearly with all stakeholders.
• Deliver a product that is reliable, secure and easy to evolve.

Key Vocabulary (Cambridge)