SDLC Phases, CASE Tools, OOAD & System Maintenance

TAKEAWAYS:

• The SDLC is a structured process (planning → analysis → design → implementation → maintenance) with 6 phases, each requiring deliverables like DFDs, ERDs, or prototypes.
• CASE tools automate SDLC phases (e.g., Lucidchart for DFDs, Visual Paradigm for UML), reducing errors and speeding up development.
• OOAD uses use cases, class diagrams, and inheritance to model real-world systems (e.g., Pathao’s driver-passenger classes).
• System maintenance includes corrective, adaptive, perfective, and preventive types, with maintainability factors like modularity and documentation.
• Context diagrams show system boundaries (e.g., Nepal Rastra Bank’s transaction system), while Level-0 DFDs break down processes (e.g., Khalti’s payment flow).
• Exam focus: Draw SDLC phase diagrams, compare waterfall vs. agile, and explain CASE tool support for each phase.

1. Systems Development Life Cycle (SDLC): Phases and Deliverables

The SDLC is a structured methodology to develop, maintain, and replace information systems. It ensures systematic planning, analysis, design, and implementation. The 6 phases are:

Phase 1: Planning

• Goal: Define system goals, feasibility, and scope.
• Deliverables:
  • Project charter (objectives, budget, timeline).
  • Feasibility study (technical, economic, operational, legal).
• Example:
  • eSewa started with a feasibility study to check if digital payments were viable in Nepal before launching.

Phase 2: Analysis

• Goal: Understand user needs and system requirements.
• Techniques:
  • Interviews, questionnaires, observation.
  • Requirements gathering (functional vs. non-functional).
• Deliverables:
  • System requirements document (SRD).
  • Use case diagrams (e.g., WhatsApp’s "Send Message" use case).
• Worked Example:
  • NTC’s online bill payment system requires:
    • Functional: "User pays bill via eSewa."
    • Non-functional: "System must handle 10,000 transactions/hour."

Phase 3: Design

• Goal: Define system architecture, interfaces, and data models.
• Sub-phases:
  1. Conceptual Design (high-level model, e.g., ER diagram).
  2. Logical Design (database schema, e.g., SQL tables).
  3. Physical Design (hardware/software specs, e.g., cloud vs. on-premise).
• Deliverables:
  • Data Flow Diagrams (DFDs) (Level 0, 1, 2).
  • Entity-Relationship Diagrams (ERDs).
  • UI/UX wireframes (e.g., Daraz’s checkout page).
• Visual: SDLC Design Phases

  flowchart LR
    A["Conceptual Design"] --> B["Logical Design"]
    B --> C["Physical Design"]
    A --> D["ER Diagram"]
    B --> E["DFD Level 1"]
    C --> F["Database Schema"]

Phase 4: Implementation (Coding)

• Goal: Develop the system using programming languages (e.g., Python for AI models, Java for Android apps).
• Techniques:
  • Prototyping (e.g., Pathao’s MVP).
  • Agile/Waterfall methodologies.
• Deliverables:
  • Source code, test cases, user manuals.

Phase 5: Testing

• Goal: Ensure the system meets requirements.
• Types of Testing:
  • Unit testing (individual modules).
  • Integration testing (module interactions).
  • System testing (end-to-end).
  • User acceptance testing (UAT).
• Example:
  • Nepal Stock Exchange (NEPSE) tests its trading platform with load testing (10,000 simulated trades/hour).

Phase 6: Maintenance

• Goal: Fix errors, adapt to changes, and improve performance.
• Types of Maintenance:

  Type	Description	Example
  Corrective	Fix bugs (e.g., Khalti’s app crash).	Patch updates.
  Adaptive	Update for new tech (e.g., NTC’s 5G readiness).	Migrate to new OS.
  Perfective	Enhance features (e.g., WhatsApp’s voice messages).	Add new functionalities.
  Preventive	Improve future maintainability (e.g., code refactoring).	Optimize database queries.

## In the Real World

1. eSewa’s SDLC:

   • Phase 2 (Analysis): Conducted surveys to identify user pain points (e.g., "I need to pay bills without visiting banks").
   • Phase 3 (Design): Designed a DFD Level 0 showing interactions between users, banks, and NTC.
   • Phase 5 (Testing): Tested with 10,000 users before full launch to catch UX issues.

2. Pathao’s Driver-Passenger System (OOAD):

   • Class Diagram:

     classDiagram
       class Driver {
         +String licenseNumber
         +String vehicleType
         +ride()
       }
       class Passenger {
         +String userID
         +bookRide()
       }
       class Ride {
         +Driver driver
         +Passenger passenger
         +status
       }
       Driver --> Ride : "offers"
       Passenger --> Ride : "books"

   • Inheritance: Driver and Passenger inherit from User (shared fields like walletBalance).

3. NTC’s Online Payment System (DFD):

   • Level 0 DFD:

     flowchart TD
       A["User"] -->|"Pay Bill"| B["Payment System"]
       B -->|"Validate"| C["NTC Database"]
       B -->|"Confirm"| A

   • Level 1 DFD: Breaks down B into:
     • Process 1: Authenticate user (e.g., via eSewa).
     • Process 2: Deduct amount.
     • Process 3: Update NTC records.

2. CASE Tools: Automating SDLC

Computer-Aided Software Engineering (CASE) tools help design, model, and document systems. Examples:

• Lucidchart (DFDs, flowcharts).
• Visual Paradigm (UML diagrams).
• ERwin (ER diagrams).
• JIRA (Agile project management).

How CASE Supports SDLC Phases

Advantages of CASE Tools

• Reduces errors (e.g., automated syntax checks in ERwin).
• Saves time (e.g., Lucidchart’s drag-and-drop DFDs).
• Improves documentation (e.g., auto-generated user manuals).

Disadvantages

• High initial cost (e.g., Visual Paradigm license).
• Steep learning curve (e.g., UML notation).
• Over-reliance on tools may reduce manual creativity.

3. Object-Oriented Analysis and Design (OOAD)

OOAD models systems using objects, classes, and relationships (e.g., inheritance, polymorphism).

Key Concepts

1. Use Case Diagrams:

   • Show actors (users) and actions (e.g., Khalti’s "Make Payment").
   • Example:

     flowchart TD
       A["User"] -->|"Make Payment"| B["Khalti System"]
       B -->|"Success/Failure"| A

2. Class Diagrams:

   • Define attributes and methods (e.g., Bank Account class).
   • Example:

     classDiagram
       class BankAccount {
         -String accountNumber
         -double balance
         +deposit(amount)
         +withdraw(amount)
       }

3. Inheritance:

   • Child classes inherit from parent classes (e.g., SavingsAccount → BankAccount).

OOAD vs. Traditional SDLC

Worked Example: Daraz Order System (OOAD)

1. Classes:
   • Customer, Order, Product, Cart.
2. Relationships:
   • Customer places Order.
   • Order contains Product.
3. Method:
   • Cart.addProduct() → Order.generateInvoice().

4. System Maintenance: Types and Factors

Types of Maintenance (Reviewed Earlier)

• Corrective, Adaptive, Perfective, Preventive.

Factors Affecting Maintainability

Maintenance Process

flowchart LR
  A["Maintenance Request"] --> B["Analyze Impact"]
  B --> C["Plan Changes"]
  C --> D["Implement Fix"]
  D --> E["Test"]
  E --> F["Deploy"]
  F --> G["Monitor"]

## Exam Tip

1. SDLC Phases:

   • Memorize the 6 phases and their deliverables (e.g., "Phase 3 delivers DFDs").
   • Draw a SDLC diagram in exams (use arrows for flow).
   • Compare waterfall vs. agile in a table (e.g., "Waterfall is rigid; Agile is iterative").

2. CASE Tools:

   • Name 2 tools (e.g., Lucidchart, Visual Paradigm) and link them to a phase (e.g., "Visual Paradigm for UML in Design").
   • Explain how CASE reduces errors (e.g., "Auto-validation in ERwin").

3. OOAD:

   • Draw a class diagram for a real system (e.g., bank account system).
   • Explain inheritance with an example (e.g., "SavingsAccount extends BankAccount").

4. Maintenance:

   • Define all 4 types and give one example each.
   • List 3 maintainability factors (e.g., "Modularity, documentation, testing").

5. DFDs:

   • Practice drawing Level 0 and Level 1 DFDs for systems like:
     • eSewa payment.
     • NTC bill payment.
   • Label processes, data stores, and external entities clearly.

SDLC phases with arrows showing flow (Image: Cliffydcw, CC BY-SA 3.0, via Wikimedia Commons)