Software Engineering Chapter 2: Software Processes

Course Content

• Chapter 1 focuses on the introduction to Software Engineering
• Chapter 2 discusses Software Processes
• Chapter 3 covers Agile Software Development
• Chapter 4 addresses Requirements Engineering
• Chapter 5 Includes System Modeling
• Chapter 6 is about Architectural Design
• Chapter 7 covers Design and Implementation
• Chapter 8 is about Software Testing
• Chapter 9 Includes Software Evolution

Agenda for Chapter 2

• Software Processes will cover these topics
• Software Process Models will cover the Waterfall Model, Incremental Development, and Reuse-Oriented Software Engineering
• Process Activities will cover Software Specification, Software Design and Implementation, Software Validation, and Software Evolution

Software Process

• It is the set of activities required to develop a software system
• The main processes in most software process models include Specification, Design and Implementation (Development), Validation, and Evolution

Software Process Types

• Plan-driven processes plan all process activities in advance
• Agile processes might change with evolving customer requirements
• Most software uses both plan-driven and agile approaches

Software Process Models

• A process model is the definition of activities and their ordering
• Process descriptions include activities, inputs/outputs, responsible people, and pre/post conditions

Common Software Process Models

• The waterfall model is a plan-driven model where all processes are separated
• Processes must be completed before the next can start
• The Incremental development model is where processes are interleaved
• Parts of specification and design can be finished and developed in parts
• The Reuse-oriented software engineering model assembles the system from existing components -This approach can be plan-driven or agile

Combining Software Process Models

• Combining software process models are common in large systems as they are not mutually exclusive
• Well-understood parts of a system can utilize a waterfall approach
• User interfaces or parts difficult to specify in advance are better suited for incremental development

Waterfall Model

• The Waterfall Model includes:
• Requirements definition
• System and Software Design
• Implementation and Unit testing
• Integration and System Testing
• Operation and Maintenance

Waterfall Model Drawbacks and Use Cases

• Requires a substantial time block to finish
• Customers have no change to alter the initial requirements
• Changes are difficult because they can only be made after the software is complete
• Best use is when requirements are well-understood
• Useful if creating software similar to existing software
• Works well for large, critical systems engineering projects developed across multiple sites

Incremental Development Model

• Involves Concurrent Activities like Specification, Outline Description, Development and Validation
• Results in initial, intermediate and final versions

Incremental Development Model Advantages

• Reduces the cost of changing customer requirements
• Makes it easier to get customer feedback
• Enables more rapid delivery and deployment of useful software

Incremental Development Model Drawbacks and Use Cases

• The process lacks visibility making it hard to produce documentation for every version
• System structure can degrade when new increments are added
• Best use is when requirements aren't clear
• Helpful when customer involvement is needed
• Useful when developing versioned software with new features

Reuse-Oriented Software Engineering

• Includes Requirements Specification, Component Analysis, Requirements Modification, and System Design with Reuse
• Development and Integration leads to System Validation
• Reuse has become the standard for many business systems

Reuse-Oriented Model Advantages

• Reduces the amount of software needed
• Reduces cost and risks
• Quickens software delivery

Reuse-Oriented Model Disadvantages

• Modified requirements can lead to systems that do not meet real user needs
• Control over system evolution is lost because reusable component updates are outside organizational control

Process Activities

• The core four activities are software specification, development, validation, and evolution
• Organization of main activities depend on the software process model
• Waterfall models organize them sequentially
• Incremental development interleaves them

Software Specification

• It is the process of defining required services and their operational constraints
• Activities involves are Feasibility Study, Requirements Elicitation and analysis and Requirements Specification

Software Development

• Software development converts system specifications into an executable system
• Software design includes designing the software structure to implement the specification
• Implementation involves translating the structure into an executable program
• Inputs include Platform Information, Requirement Specifications and Data Description
• Activities involve Architectural, Interface, Database and Component Design
• Outputs include System Architecture, Database Specification, Interface Specification and Component Specification

Software Implementation

• Happens naturally after the software design
• Programming is personal and lacks a general process
• Programmers start with components they understand or those less familiar
• Programmers commonly test code that can reveal program defects
• Debugging refers to removing these defects

Software Validation

• Verification and validation (V & V) aims to show that a system conforms to its specification and meets the customer's requirements
• Software Validation involves component , system, and acceptance testing

Validation Details

• Acceptance testing is sometimes called 'alpha testing'
• 'Beta testing' is used for software products, involving system delivery to potential customers
• Customers report problems to system developers
• Beta testing exposes the product to real-world use and finds unanticipated errors

Software Evolution

• Software evolution occurs when altering existing software to meet new requirements
• Software must evolve to stay useful
• Its activities include defining system requirements, assessing existing systems, proposing changes, and modifying systems