Embed Size (px)
Citation preview
CS 5150 1
CS 5150 Software Engineering
Lecture 3
Software Processes 2
CS 5150 2
Administration
Project teams
• Any announcement to class?
• People who would like to form teams?
Project Suggestions on the web site
Entrepreneurship experiment
CS 5150 3
Administration
Project teams
When you have formed your team and reached agreement with your client, please send a message to:
[email protected] and [email protected]
with the names of the team, the client's name, and the topic of the project.
CS 5150 4
Basic Process Steps in all Software Development
• Feasibility and planning
• Requirements
• System and program design
• Implementation
• Acceptance and release
• Operation and maintenance
In a lightweight process, these steps are repeated with each increment
CS 5150 5
Process Step: Feasibility
A feasibility study precedes the decision to begin a project.
• What is the scope of the proposed project?
• Is the project technically feasible?
• What are the projected benefits?
• What are the costs, timetable?
A feasibility study leads to a decision: go or no-go.
CS 5150 6
Process Step: Requirements
Requirements define the function of the system from the client's viewpoint.
The requirements establish the system's functionality, constraints and goals by consultation with the client, customers, and users.
The requirements may be developed in a self-contained study, or may emerge incrementally.
CS 5150 7
Process Step: System and Program Design
Design describes the system from the software developers' viewpoint
System design: Establish a system architecture that matches the requirements to hardware or software systems.
Program design: Represent the software functions in a form that can be transformed into one or more executable programs
CS 5150 8
Process Step: Implementation
Implementation (coding)
The software design is realized as a set of programs or program units.
The software components may be written specifically, acquired from elsewhere, or modified.
CS 5150 9
Process Step: Acceptance and Release
Acceptance
The system is tested against the requirements by the client, often with selected customers and users.
Delivery and release
The system is delivered to the client and released into production or marketed to customers.
CS 5150 10
Testing
User testing
A preliminary version of the user interface is tested by users. Their experience may lead to changes in the requirements or the design.
Program testing
The development team tests components individually (unit testing) or in combination (system testing) to find bugs, etc.
Acceptance testing
The client tests the final version of the system or parts of the system against the requirements.
CS 5150 11
Process Step: Operation and Maintenance
Operation: The system is put into practical use.
Maintenance: Errors and problems are identified and fixed.
Evolution: The system evolves over time as requirements change, to add new functions or adapt the technical environment.
Phase out: The system is withdrawn from service.
This is sometimes called the Software Life Cycle
CS 5150 12
Sequence of Processes
Every software project will include these basic processes, in some shape or form, but:
• They may be formal or informal
• They may be carried out in various sequences
Deliverables
In a heavyweight process, each process step creates a deliverable, usually documentation, e.g., a requirements specification.
In a lightweight process, the deliverables are incremental working code, with minimal supporting documentation.
CS 5150 13
Sequence of Processes
Major alternatives
• Sequential: As far as possible, complete each process step before beginning the next. Waterfall model.
• Iterative: Go quickly through all process steps to create a rough system, then repeat them to improve the system. Iterative refinement.
• Incremental: An extension of iterative refinement in which small increments of software are placed in production. Agile development.
CS 5150 14
Sequential Development:The Waterfall Model
Requirements
System design
Testing
Operation & maintenance
Program design
Implementation (coding)
Acceptance & release
Requirements
Design
Implementation
Feasibility study
CS 5150 15
Iterative Refinement
Requirements
DesignImplementation
Evaluation
CS 5150 16
Incremental Development
• Each iteration involves a team working through a full software development cycle including planning, requirements analysis, design, coding, unit testing, and acceptance testing.
• Each increment is completed in a fixed time period, e.g., four weeks.
• The size of an increment is based on team size, e.g., 5-10 people.
Increment 1
Accept Increment 1
Increment 2 Increment 3
Accept Increment 2
Accept Increment 3
CS 5150 17
Discussion of the Waterfall Model
Advantages:
• Process visibility• Separation of tasks• Quality control at each step• Cost monitoring at each step
Disadvantages:
Each stage in the process reveals new understanding of the previous stages, which often requires the earlier stages to be revised.
The Waterfall Model is not enough!
CS 5150 18
Sequence of Processes
A pure sequential model is impossible
Examples:
• A feasibility study cannot create a proposed budget and schedule without a preliminary study of the requirements and a tentative design.
• Detailed design or implementation usually reveals gaps in the requirements specification.
The plan must allow for some form of iteration.
CS 5150 19
Modified Waterfall Model
Requirements
System design
Testing
Operation & maintenance
Program design
Implementation (coding)
Acceptance & release
Waterfall model with feedback
This is better
Feasibility study
CS 5150 20
Discussion of Iterative Refinement
Concept: Initial implementation for client and user evaluation, but not for release, followed by refinement until system is complete.
• User interface mock-up
• Throw-away software components
• Dummy modules
• Rapid prototyping
• Successive refinement
CS 5150 21
Iterative Processes: Requirements and Risk
Mistakes in the requirements are the most expensive to correct.
Requirements are hard to understand until there is an operational system, particularly with user interfaces
Create an outline system quickly, review it with clients, test it with users, improve the understanding of the requirements
Example: Start-up time of launching a complex application.
CS 5150 22
Incremental Development: Discussion
A simple system with basic functionality is brought quickly into production. Subsequent increments are based on experience gained from users of each previous release.
Advantages
• Pay-back on investment begins soon.
• Requirement are more clearly understood in developing subsequent increments – minimize waste.
• User feedback can be incorporated in later phases.
Challenge
A high-level team must establish overall architecture and coordinate increments
CS 5150 23
Incremental Development of Online Systems
When software is released online it is possible to divide it into small increments that are developed and released in quick succession.
This approach is excellent for continual enhancement of a system within an established architecture.
It is not possible for shrink wrapped software, embedded systems, or similar environments.
CS 5150 24
Mixed Processes
In practice, many large projects create a process that is suitable for the specific development. For example:
• A system may use a sequential process with iteration within the individual process steps. This is sometimes called a spiral development process.
• User interfaces have to be tested with users. This forces iterative development, even within an underlying sequential process.
• A phase 1 system may be developed by iteration and used as requirements for a phase 2, which is developed sequentially.
CS 5150 25
Examples of Mixed Processes:Iterative Refinement + Waterfall Model:
Problem: Add graphics package to a programming environment
Phase 1: Iterative refinement
Extend current environment with a preprocessor and run-time support package. Test with users. Make several new versions until users are pleased with function. Throw the code away.
Phase 2: Modified waterfall
Use the results of Phase 1 as the basis for a formal set of requirements. Write new compiler and run-time system incorporating graphics elements. Make minor adjustments to requirements as needed.
CS 5150 26
Corporate Processes
Large software development organizations have their own internal processes that are designed for their needs. For example:
• Amazon.com (Internet commerce) divides most software development into phases of about four weeks elapsed time.
• Lockheed Martin (government contactor) follows a process that fits with the way that the US government manages software contracts.
• SAP (business software) emphasizes the functionality that is seen by their business customers.
• Microsoft (PC software) places great emphasis on testing with a very wide variety of equipment and backward compatibility.
CS 5150 27
Modern Developments in Software Processes
Changes during the software development process are expensive.
• If the requirements are poorly understood, or expected to change, select a process that keeps flexibility. Iterative refinement, phased implementation.
• For big software systems with many inter-related components, avoid major changes to the design of a system during development. Sequential process, such as the modified waterfall model.
• If the market for the software is poorly understood, use an incremental process that gets operational software in front of customers as quickly as possible.
CS 5150 28
Observations about Software Processes
Completed projects should have the basic process stepsbut ... the development process is always partly evolutionary.
Risk is lowered by:
• Prototyping key components
• Frequent releases, dividing large projects into phases
• Early and repeated testing with users and customers.
• Following a visible software process
• Making use of reusable components
CS 5150 29
CS 5150 Project Presentations: Iterative Option
Requirements
DesignImplementation
Evaluation
first presentation
second presentation
third presentation
CS 5150 30
CS 5150 Project Presentations: Sequential Option
Requirements
System design
Testing
Operation & maintenance
Program design
Implementation (coding)
Acceptance & release
1. Requirements
2. Design
3. Implementation
Feasibility study
If you follow a sequential process the three presentations should be as shown.
CS 5150 31
CS 5150 Project Presentations: Incremental Development
Increment 1
First release
Increment 2 Increment 3
Second release
Third release
first presentation second presentation third presentation
