Software process

The Software process

[What is a software process?]

• A set of related activities that leads to the production of a software

[4 fundamental SE activities in many different SW processes]

• SW Specification: Defining the functionality of the software and constraints on its operation
• SW Development: Producing the software to meet the specification
• SW Validation: Checking that the software does what the customer wants
• SW Evolution: Evolving the software to meet changing customer needs

[When Describing the SW process, it is also critical to describe:]

• Product & Deliverables: The outcomes of a process acitivity
• Roles: The responsibilities of the people involved in the process
• Pre- and post- conditions: Contiditions that must hold before and after a process activity

[What is a software process model?]

• A simplified representation of a software process (= High-level, abstract descriptions of software processes)
  

Plan-driven and agile processes

[In plan-driven processes]

• All of the process activities are planned in advance.
• ex) Safety-critical systems (자율 주행 차)

[In agile processes]

• Planning is incremental and continual during SW development.
• ex) Business systems with rapidly changing requirements

Generally, for large systems, we need to find a balance between plan-driven and agile processes.

Software process models

Software process models (SW Development Life Cycle models)

• The waterfall model: Representing the fundamental process (S -> D -> V -> E) activities as separate process phases. (e.g., a plan-driven process)

• Incremental development: Interleaving the fundamental process activities. Developing as a series of versions (increments) (e.g., a Agile process)

• Integration and configuration: Relying on reusable software components and an integrating framework for the composition of the components.

In practice, most large systems are developed using a process that incorporates elements from all of these models.

The waterfall model

• Planning all of the process activities before starting SW development.
• Reflecting the fundamental SW development activities directly.
  

1. Requirements analysis and definition
2. System and software design
3. Implementation and unit testing(부분 testing)
4. Integration and system testing(전체 testing)
5. Operation and maintenance

Incremental development (model)

• Three activities are interleaved rather than separate.
• Developing an initial implementation, getting feedback from users, and evolving the software through several versions.
  

Incremental development benefits

• Cost reduction
  • The amount of documentation: Incremental development < waterfall model
• Easy feedback
  • Customers can comment on demonstrations of the software.
• Early deployment
  • Customers are able to gain value from the software earlier (vs a waterfall process).

Incremental development problems

• The process is not visible.
  • Need regular deliverables to measure progress.
  • If systems are developed quickly, it is not cost-effective to produce documents that reflect every version of the system.
• System structure tends to degrade as new increments are added.
  • Regular change leads to messy code.
  • It becomes increasingly difficult and costly to add new features to a system.
  • solution: should regularly refactor (improve and restructure) the software.

Integration and configuration (model)

• Integrating existing reusable components into a software rather than developing it from scratch.
  

[Key process of reuse-oriented SE]

• Requirements specification: Don't have to be elaborated in detail but include brief descriptions of essential requirements.

• Software discovery and evaluation: Search and evaluate the components and systems that provide the required functionality. "code search"

• Requirements refinement: Refine the requirements using information about the reusable components that have been discovered.

• Application system configuration: COTS(상용 소프트웨어) application system is configured for use to create the new system. (COTS is available)

• Component adaptation and integration: Reusable components and newly developed components are integrated to create the system. (COTS is not available)

Reuse-oriented software engineering

[Advantages]

• Reducing the amount of software to be developed (cost, risk 감소)
• Faster delivery of the system

[Disadvantages]

• A system may not meet real needs of users because requirement compromises are inevitable.
• Some control over the system evolution is lost.

Process activities

Process activities

• The 4 basic process activities
  • Specification, Development, Validation, and Evolution.
• These are organized differently in each development process.
  • Waterfall model
    • The activities are organized in sequence. (S -> D -> V -> E)
  • Incremental development
    • The activities are interleaved. (S <-> D <-> V)

1. Software specification (Requirements Engineering)

[Software Specification or requirements engineering]

• Understanding and defining what services are required from the system.
• Identifying the constraints on the system's operation and development.
• The mistakes will lead to later problems in the system design and implementation.

[Requirements engineering process]

• Requirements elicitation(이끌어 냄) and analysis
  • Deriving the system requirements throught observation of existing systems and discussions with protential users. (proto types)
• Requirements specification
  • Translating the information gathered into a document that defines a set of requirements
• Requirements validation
  • Checking the requirements for realism, consistency, and completeness.
    

2. Software design and implementation

[Software design activities]

• Architectural design: Identifying the overall structure of the system, the principal components, and their relationships.

• Database design: Designing the system data structures and how these are to be represented in a database.

• Interface design: Defining the interfaces between system components.

• Component selection and design: Searching for reusable components and designing new software components.

[A general model of the design process]

[Implementation]

• Programming is an individual activity with no standard process.

• Testing aims to reveals program bugs that must be removed from the program. (Generate bug triggering test-cases -> maximize code coveraging)

• Debugging is concerned with locating and correcting these bugs.

3. Software validation

[Software validation] or [Verification and validation (V&V)]

• Checking whether a system conforms to its specification and meets the requirements of the system customer.
• Checking at each stage of the software process from user requirements definition to program development.
  • Program testing > user requirements

[States of testing]

• Component testing: Testing Individual components (e.g., functions) independently. (The programmer is the best person to generate test cases.)

• System testing: Testing the entire system in which the components are integrated.

• Customer testing: Tested by the system customer rather than with simulated test data. (Beta testing)
  

[Testing phases in a plan-driven software process (V-model) (Waterfall model)]

• Illustrating how test plans are the link between testing and development activities.
  

4. Software evolution

[Software evolution]

• Software is inherently flexible and can change.
• Even extensive changes of SW are still much cheaper than the changes of HW.
• This distinction between development and maintenance is increasingly inrrelevant.
  -Seeing development and maintenance as a continuum(연속체).

Coping with change

[Change is inevitable in all large software projects.]

[2 approaches for reducing the costs of rework.]

• Change anticipation: Including activities that can anticipate possible changes before significant rework is required. (e.g., prototype system)

• Change tolerance: The process is designed so that changes can be easily made to the system. (e.g., incremental development, refactoring)

[2 ways of coping with change.]

• Prototyping
• Incremental delivery

Software prototyping

[Benefits of prototyping]

• Allowing potential users to see how well the system supports their work.
• Revealing errors and omissions in the system requirements.
• Reflecting the changed understanding of the requirements.
• The only sensible way to develop user interfaces.

[Problems of prototyping]

• Using the prototype system != Using the final system.
• Prototype testers != typical of system users.
• Avoid those system features that have slow response times.

[Prototype development]

• Key point: Deciding what to leave out(뭘 버릴지) of the prototype system.
  • Leaving out some functionality of the prototype.
  • Relaxing non-functional requirements (e.g., response time and memory usage).
  • Ignoring error handling and management.
    

Incremental development and delivery

[Incremental delivery]

• Deliver some of the developed increments to the customers.
• Define which of the services are most important to the customers.
  

[Incremental delivery advantages]

• Customers can use the early increments as prototypes and gain experience. or (Customers do not have to wait until the entire system is delivered)
• Relatively easy to incorporate changes into the system.
• The most important system services receive the most testing.

[Incremental delivery disadvantages]

• When replacing an existing system with the new system, users need all of the functionality of the old system.
• As requirements are not defined in detail, it can be hard to identify common facilities that are needed by all increments.

Process improvement

• Understanding existing processes and changing these processes to increase product quality and/or reduce costs and development time.

• The process maturity(성숙함) approach

  • Improving process and project management.
  • Introducing good software engineering practice into an organization.

• The agile approach (The process maturity approach와 반대)

  • Iterative development and the reduction of overheads in the software process.

Summary