Software Development Process Notes

Software Process Model

  • Definition: A simplified representation of a software process, presented from a specific perspective.

Generic Software Process Activities

  • Specification: Defining what the system should do and its development constraints.
  • Development: Production of the software system.
  • Validation: Checking that the software meets customer requirements.
  • Evolution: Adapting the software in response to changing demands.

Types of Model

  • Traditional
  • Evolutionary
  • Component Based
  • Iterative and Incremental
  • Agile

Traditional Model: Waterfall

  • Structured and easy to understand (theoretically).
  • Issues:
    • Customer requirements are ever-changing.
    • Few requirements remain stable.
    • Approximately 40% of software projects fail due to requirement issues.
  • Suitable for:
    • Large projects at multiple sites.
  • Characteristics:
    • One phase must be completed before moving to the next.
    • Rigid.
  • Improvement: Cyclic Waterfall model.

Evolutionary Model

  • Based on Charles Darwin's Theory of Evolution.

Types of Evolutionary Development:

  • Exploratory Development
  • Throw-away Prototyping

Exploratory Development

  • Objective:
    • Collaborate with customers.
    • Evolve a final system from an initial outline specification.
  • Process:
    • Start with well-understood requirements.
    • Incorporate new features suggested by the customer.
  • Deliverable:
    • The refined system.

Throw-away Prototyping

  • Objective:
    • Thoroughly understand the system requirements.
    • Suitable for clients unsure of their needs.
  • Process:
    • Start with poorly understood requirements to clarify needs.
    • Discard the prototype once requirements are confirmed.
    • Build a new system based on clarified requirements.

Evolutionary: Applicability & Problems

  • Applicability:
    • Small to medium-size interactive systems.
    • Parts of large systems (e.g., user interface).
    • Short-lifetime systems.
  • Problems:
    • Lack of process visibility.
    • Systems often poorly structured.
    • Requires special skills (e.g., rapid prototyping languages).

Reusing Approach: Component Based Software Engineering

  • Concept: Reusing existing components or COTS (Commercial-off-the-shelf) systems.
  • Approach:
    • Standard components.
    • 'Plug' and use.

Process:

  • Component analysis
  • Requirements modification
  • System design with reuse
  • Development and integration
  • System validation

Modern Approach: Incremental & Iterative Development

  • Incremental Development: Scheduling and staging strategy where different parts of the system are developed and integrated at different times or rates.
  • Iterative Development: Rework scheduling strategy where time is allocated to revise and improve parts of the system. Works well with incremental development.

Iterative & Incremental Models

  • Spiral Model
  • Agile Software Development

Spiral Model

  • Process represented as a spiral, not a sequence of activities with backtracking.
  • Each loop represents a phase.
  • No fixed phases; loops depend on requirements.
  • Risks are explicitly assessed and resolved.

Spiral Sectors

  • Objective setting: Specific objectives for the phase.
  • Risk assessment and reduction: Assessing risks and implementing activities to reduce them.
  • Development and validation: Choosing a development model (can be any generic model).
  • Planning: Reviewing the project and planning the next phase.

Steps in Spiral Model

  1. Define new system requirement
  2. Analyze risk
  3. Create preliminary design
  4. Construct prototype from preliminary design
  5. Test the prototype
  6. Develop second prototype after:
    1. Evaluating the first prototype
    2. Defining requirements for the second prototype
    3. Designing the second prototype

Agile Software Development

  • Identify the high-level scope
  • Identify initial "requirements stack"
  • Identify an architectural vision
  • Work through specific issues in a JIT (Just-In-Time) manner
  • Stakeholders actively participate
  • Requirements evolve throughout the project
  • Develop working software in an evolutionary manner
  • Implementation (Ideally Test Driven)

Well Known Agile Methods

  • Agile Modelling
  • Agile Unified Process (AUP)
  • Extreme Programming
  • Feature Driven Development (FDD)

Extreme Programming Model

  • Involves release planning, iteration planning, acceptance tests, stand-up meetings, pair negotiation, unit tests, pair programming, and coding.
Extreme Programming
  • Objective: Improve software quality and responsiveness to user-changing requirements.
  • Characteristics:
    • Time-boxing, releases.
    • Short development cycles.
    • Pair programming.
    • User-changing requirements are expected.

Other Approaches: V-Model

  • The V-Model illustrates the relationship between development and testing phases.

Rational Unified Process (RUP) by IBM

  • Iterative software development.
  • Development framework created by IBM in 2003.
  • Adaptable framework intended to be tailored.

Principles of RUP

  • 3 building blocks
  • 6 engineering disciplines
  • 3 supporting disciplines

RUP Building Blocks

  • Role: Defines related skills, competences, and responsibilities (who).
  • Work Product: Represents a deliverable from a task, including documents and models (what).
  • Task: Describes a unit of work assigned to a Role, providing a meaningful result (how).

Engineering Discipline

  • Business Modeling
  • Requirements
  • Analysis & Design
  • Implementation
  • Test
  • Deployment

Supporting Discipline

  • Configuration & Change Mgmt
  • Project Management
  • Environment

Essence of Choosing a Model

  • Pick a suitable model based on time, manpower, and resources.
  • Customize the model to fit the project.
  • Adhere to milestones.

Process Activities

  • Refinement of Process Activities:
    • Specification
    • Development
    • Validation
    • Evolution

Detailed Breakdown of Activities

  • Requirement
  • Specification
  • Architecture
  • Design
  • Implementation
  • Testing
  • Deployment
  • Maintenance

Requirement

  • Capture requirements using various techniques
  • Understand user problems
  • Determine what the user wants the system to do
  • Identify suitable technology
  • Output:
    • Software Development Plan (SDP)
    • Software Requirement Analysis (SRA)
    • Various documentations recording requirement capturing session

Specification

  • Models requirement
  • Write requirement specification
  • Sketching user interface
  • Define what the system is supposed to do
  • Define what are the data used, create and store in the system
  • Output:
    • Software Requirement Specification (SRS)

Architecture

  • Define how the system is supposed to look like
  • Define high-level design
  • Determine system architecture (Stand-alone? Web-based? Distributed? Parallel Processing? Client-Server?)
  • Select components to use
  • Determine the number of modules
  • Develop integration test plan
  • Design data repository
  • Output:
    • High-Level Design
    • Integration Test Plan (ITP)

Design

  • Write functions, algorithm
  • Select components
  • Define component interfaces
  • Define system behavior and response to invocations
  • Output:
    • Software Detail Design (SDD)
    • Unit Test Plan (UTP)

Implementation

  • Write program code
  • Debug program
  • Conduct code review
  • Integrate modules
  • Perform unit testing
  • Verify system functionality
  • Output:
    • Result of Unit Test Plan

Testing

  • Integration Testing
  • Code review
  • Debugging
  • User acceptance test
  • Verify if the system fulfills all requirements in SRA and SRS
  • Output:
    • Software Test Result (STR)

Deployment

  • Hand over the system
  • Install the system at the client’s site
  • Provide training
  • Verify successful system operation

Maintenance

  • System in operation
  • Managing files and data
  • Address change requests / additional features
  • Maintenance as another system life cycle.