1. Software Development Process CS 360 Lecture 3

2. Software Process The software process is a structured set of activities required to develop a software system. Fundamental Assumption:  Good software processes lead to good software.  Good software processes reduce risks. 2

3. Basic Process Steps in all Software Development Feasibility and planning Requirements System and program design Implementation Acceptance and release Maintenance 3

4. Basic Process Steps in all Software Development Feasibility and planning Requirements System and program design Implementation Acceptance and release Maintenance It is important to distinguish among these process steps and to be clear which you are doing at any given moment. 4 These steps may be repeated many times during the development cycle.

5. Quality control steps in all software development (documentation) Validating the requirements Validating the system and program design Usability testing  User interface Program testing  Syntax, logical Acceptance testing  Determine if the specified requirements are met Bug fixing, feature enhancements, and maintenance 5

6. Categories of testing The term “testing” is used in several different contexts, which can be confusing: User testing:  Versions of the user interface are tested by users and clients.  Their experience may lead to changes in the requirements or design. Program testing:  The development team tests components individually (unit testing) or in combination (system testing) against the design to find bugs, etc. Acceptance testing:  The client tests the final version of the system or parts of the system against the requirements. 6

7. Process Step: Feasibility The feasibility study:  What is the scope of the proposed project?  Is the project technically feasible?  What are the projected benefits?  What are the costs?  Expected timeline?  What resources are needed?  What are the risks and how can they be managed? 7

8. Process Step: Requirements Requirements define the function of the system from the client’s viewpoint. Requirements establish:  System functionality  Constraints  Goals 8

9. Process Step: Requirements The requirements step is divided into tasks:  Requirements analysis  Requirements definition  Requirements specification The project’s requirements may be developed in a self- contained study, or developed incrementally. Failure to agree on the requirements and define the adequately is one of the main causes of software projects failing. 9

10. Process Step: Requirements The requirements step is divided into tasks:  Requirements analysis  Meetings, documentation, process specifications, use cases, etc.  Requirements definition  Description of the services that the system should provide.  Requirements specification  Functional requirements  Inputs, behavior, outputs  Non-functional requirements  Criteria used to judge the operation of the system  Ex: accessibility, compliance, privacy, performance, reusability, stability, usability, etc. The project’s requirements may be developed in a self-contained study, or developed incrementally. Failure to agree on the requirements and define the adequately is one of the main causes of software projects failing. 10

11. Process Step: System and Program Design Design describes the system from the software developers’ viewpoint. System design:  Establish a system architecture, both hardware and software, that matches requirements. Program design:  Represent the software functions in a form that can be transformed into one or more executable programs. Preliminary user testing can be carried out as part of the design step. Models are used to represent requirements, system architecture, and programming design.  This course covers the basic concepts of the Unified Modeling Language (UML). 11

12. Process Step: Implementation Implementation (coding):  The software design is realized as a set of programs.  These software components may be written by the development team, or modified from existing components. Program testing:  Individual components (unit testing) should be tested against the design documentation.  All components are integrated and tested against the design as a complete system (system testing). 12

13. Process Step: Acceptance and delivery Acceptance testing:  The system is tested against the requirements by the client.  Can be done in weekly meetings, or after each milestone delivery. Delivery:  After successful acceptance testing, the system is finally delivered to the client and released into production. 13

14. Process Step: Operation and maintenance Operation:  The system is moved from the developmental phase into practical use. Maintenance:  Errors and problems are identified and fixed. Evolution:  The system evolved over time as requirements change.  Add new functionality  Increased stability  Adapt to changing technical environment Phase out:  The system is withdrawn from service. This is generally called the Software Life Cycle. 14

15. Software engineering Processes Every software project will include the previous basic processes, in some shape or form, but:  The steps may be formal or informal  The steps may be carried out in different order Your job as the software development team is to implement, in as much detail as possible, the processes described in order to develop a good software product. 15

16. Sequence of processes In this course, we will look at three categories of software development processes:  Sequential:  As much 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 to improve the system.  Prototype, test, analyze, refine, repeat..  Iterative refinement, entire system  Incremental:  Variation of the iterative refinement in which small increments of software are placed in production (sprints).  Prototype, test, analyze, repeat..  Agile refinement, adding individual features during each phase. 16

17. Deliverables Deliverables:  A deliverable is some work product that is given to the client.  Each process step mentioned previously creates a deliverable.  Documentation, source code, etc. For this course, the deliverables include:  Presentations  Software process documentation(s)  Software and/or hardware resources 17

18. Three Types of Software Process

19. Types of software process The basic process steps can be combined in many ways to create a successful software process for development. Three types of software process:  Sequential ((modified) waterfall model), plan-driven  Iterative refinement  Incremental (agile) 19

20. Types of software process Plan-driven processes have all process activities described in advance and progress is measured against this plan. Agile processes have incremental planning stages, where change can be accommodated more easily to reflect updated client requirements. In practice, most approaches include elements of both plan-driven and agile development processes. 20

21. Sequential development: waterfall model 21

22. Discussion of the waterfall model The waterfall model requires full documentation at each process step. Advantages:  Process visibility  Separation of tasks  Quality control at each step  Cost monitoring at each step Disadvantages:  In practice, each process stage reveals new understanding of the previous stages.  Often requires earlier stages to be revised. 22

23. Discussion of the waterfall model A pure sequential model is impossible  Example:  A feasibility study can’t cerate a proposed budget and schedule without a study of the requirements and initial design.  Detailed design and implementation reveal gaps in the requirement specifications.  Requirements and/or technology may change during project development. Solution:  Modified waterfall model 23

24. Modified waterfall model 24

25. Sequential Development Sequential processes work best when the requirements are well understood, and the design is straightforward.  Ex:  Conversions of existing manual data processing systems.  New models of a product based on earlier versions or similar products.  Parts of a larger system where components are clearly defined. 25

26. Iterative Processes Concept:  Create a prototype system early in the development process  Review the prototype with clients and test it with users  To improve the understanding of the requirements  Clarify the design Requirements can be difficult to understand until there is an operational system. Mistakes in the requirements are the most expensive to correct. 26

27. Iterative Refinement 27

28. Iterative Processes Iterative processes require documentation refinement during each phase. This type of software process enables the client to review the planned system early during development:  Software/hardware mock-ups  Sandbox modules  Rapid prototyping  Feature refinement The goal is to get something working as quickly as possible, for client and user evaluation, but do not release it. 28

29. Incremental Development (sprints) The project is divided into a large number of small tasks, known as sprints. For each sprint, the team works through a full software development cycle: planning, requirements, analysis, design, coding, testing, acceptance testing, and release. Each sprint is completed in a fixed time period, or milestone. The size of a sprint is based on team size  4-7 people. 29

30. Incremental Development 30

31. Thoughts about software process Completed projects should have included all of the basic process steps, but the development process is always partly evolutionary. Risks are lowered by:  Prototyping key components  Frequent releases, or dividing into phases  Early and repeated testing with users and clients  Making use of reusable components 31

32. CS 560 Projects: Iterative Refinement 32

33. CS 560 Projects: Incremental Development 33

34. CS 560 Projects: Sequential Development 34