1.  CS 5380 Software Engineering Chapter 2 – Software Processes Chapter 2 Software Processes1

2. Processes and Process Models  Software processes  A ctivities involved in producing a software system.  Software process models  abstract representations of these processes. Chapter 2 Software Processes2

3. Software processes  Processes  Specification  Design  Implementation  Validation  Evolution  Occur in all process models Chapter 2 Software Processes3

4. Process Models  Describe the organization of software processes.  Key Examples  Waterfall model  Incremental development  Reuse-oriented development. Chapter 2 Software Processes4

5. Software Process Pescriptions  Activities of the process  Specifying a data model  Designing a user interface  Also  Outcomes of a process  Roles of people involved in the process  Pre- and post-conditions Chapter 2 Software Processes5

6. Software process models  Waterfall model  Plan-driven model.  Separate and distinct processes  specification  development.  Incremental development  Interleaved processes  Specification, development and validation  Reuse-oriented software engineering  The system is assembled from existing components. Chapter 2 Software Processes6

7. Development in Civil Engineering  Build a bridge  Requirements  Site Analysis  Design  Review/Approval  Schedule  Construction  Testing  Maintenance  Discussion  Requirements  Overlap of phases  Dependency of Phases Chapter 2 Software Processes7

8. The Waterfall Model (1970) Chapter 2 Software Processes8

9. Waterfall Model Phases  There are separate identified phases in the waterfall model:  Requirements analysis and definition  System and software design  Implementation and unit testing  Integration and system testing  Operation and maintenance Chapter 2 Software Processes9

10. Waterfall Model Problems  Responding to changing customer requirements.  Appropriate  requirements are well-understood  Changes will be fairly limited  Few business systems have stable requirements. Chapter 2 Software Processes10

11. Waterfall Applications  Large systems, developed at several sites.  Space Shuttle control system  Integration with many physical components Chapter 2 Software Processes11

12. Incremental Development  Initial Requirements, Design, Development…  Learn from usage  Modify requirements, design, redevelop Chapter 2 Software Processes12

13. Incremental development Chapter 2 Software Processes13

14. Incremental development benefits  Lower cost of accommodating changing customer requirements  Better customer feedback  Customers understand working system better than design  More rapid delivery  Partial delivery at beginning is useful Chapter 2 Software Processes14

15. Generic Products  Inherently incremental  Initial phase to  Get customers  Get feedback  Drive direction  Subsequent phases  Stay competitive  Meet changing needs Chapter 2 Software Processes15

16. Incremental development problems  The process is not visible.  Design documents not at extensive  Design documents not final  System structure tends to degrad e as new increments are added.  New features may not fit initial structure Chapter 2 Software Processes16

17. Reuse-Oriented Software Engineering  Systematic reuse  COTS (Commercial-off-the-shelf) systems.  Process stages  Component analysis;  Requirements modification;  System design with reuse;  Development and integration.  Standard approach for building many systems  SAS Chapter 2 Software Processes17

18. Reuse-oriented software engineering Chapter 2 Software Processes18

19. Types of software components  Web services  Standard specification  Remote invocation  Calendar, weather, scheduling, RSS,…  Collections of objects - framework .NET  User interface  Configurable software systems  COTS – Commercial Off The Shelf software  SAS Chapter 2 Software Processes19

20. Discussion  Identify 2 highly likely projects for each of the following  Waterfall  Incremental  Component Chapter 2 Software Processes20

21. Software Specification  Process of establishing  Services required  Constraints on the system  Requirements engineering process  Feasibility study  Requirements elicitation and analysis  Requirements specification  Requirements validation Chapter 2 Software Processes21

22. The requirements engineering process Chapter 2 Software Processes22

23. Software design and implementation  Design  Creation of design documents  From requirements  Implementation  Creation of running program  From design documents  Design and implementation  Closely related  May be inter-leaved. Chapter 2 Software Processes23

24. A general model of the design process Chapter 2 Software Processes24

25. Design activities  Architectural design,  overall structure  principal components (sub-systems or modules)  component relationships  Interface design  interfaces between system components  Interface with user  Component design  Individual component  Database design,  Tables, queries, interaction Chapter 2 Software Processes25

26. Software verification and validation  Show that  system conforms to its specification  meets the real needs of customer  Testing is a key approach  Code reviews Chapter 2 Software Processes26

27. Stages of testing Chapter 2 Software Processes27

28. Testing stages  Development or component testing  System testing  Acceptance testing Chapter 2 Software Processes28

29. Testing phases in a plan-driven software process Chapter 2 Software Processes29

30. Software evolution  Software is inherently flexible.  Software changes to meet  Changing business model  New applications Chapter 2 Software Processes30

31. System evolution Chapter 2 Software Processes31

32. Nature of Change  Change is inevitable in all large software projects.  Business changes  New technologies  Changing platforms  Changing Customer Base  Chaging usage Chapter 2 Software Processes32

33. Reducing the Costs of Rework  Change avoidance  Start with a prototype   Change tolerance  Incremental tolerance  Architecture Chapter 2 Software Processes33

34. Software prototyping  Prototype  initial version  demonstrate concepts  try out design options.  Uses:  requirements elicitation and validation;  UI design; Chapter 2 Software Processes34

35. Benefits of prototyping  Improved system usability.  A closer match to users’ real needs.  Improved design quality.  Improved maintainability.  Reduced development effort. Chapter 2 Software Processes35

36. The process of prototype development Chapter 2 Software Processes36

37. Prototype development  Tools  rapid prototyping languages  Leave out functionality  Focus on areas that are not well-understood  No error checking and recovery  Focus on functional requirements  not reliability and security  Different architecture Chapter 2 Software Processes37

38. Throw-away prototypes  Discard prototype:  Can’t be modified for all requirements;  Prototypes are undocumented;  Poor internal structure;  Poor quality standard Chapter 2 Software Processes38

39. Discussion  Describe a prototype for  Web application  Mobile app  Air traffic control system  Integrated controller in a printer Chapter 2 Software Processes39

40. Incremental delivery  Multiple deliveries  Phased functionality  Requirements prioritization  Requirements frozen at beginning of incremental phase Chapter 2 Software Processes40

41. Incremental development and delivery  Incremental development  Evaluate each increment before creating next  Normal approach used in agile methods;  Evaluation done by user/customer proxy.  May not require incremental delivery  Incremental delivery  Deploy to end-users  More realistic evaluation by users; Chapter 2 Software Processes41

42. Incremental delivery Chapter 2 Software Processes42

43. Incremental delivery advantages  Partially usable system available earlier.  Early versions elicit further requirements  Lower risk of overall project failure.  Most important features get tested more Chapter 2 Software Processes43

44. Incremental Delivery Problems  Common facilities.  Not fully thought out  Poorly architected  Conflicts with procurement processes  Companies require full specification Chapter 2 Software Processes44

45. Boehm’s spiral model (1988)  Spiral diagram rather than process diagram  Each loop in the spiral represents a phase in the process. Chapter 2 Software Processes45

46. Boehm’s spiral model of the software process Chapter 2 Software Processes46

47. Spiral model sectors  Objective setting  Specific objectives for the phase are identified.  Risk assessment and reduction  Risks are assessed and activities put in place to reduce the key risks.  Development and validation  A development model for the system is chosen which can be any of the generic models.  Planning  The project is reviewed and the next phase of the spiral is planned. Chapter 2 Software Processes47

48. Spiral model usage  Rarely used as published for practical software development. Chapter 2 Software Processes48

49. The Rational Unified Process  IBM 2003  Combination of other models  Largely iterative  Documentation  Prototyping Chapter 2 Software Processes49

50. Phases in the Rational Unified Process Chapter 2 Software Processes50

51. RUP phases  Inception  Establish the business case for the system.  Elaboration  Develop an understanding of the problem domain and the system architecture.  Construction  System design, programming and testing.  Transition  Deploy the system in its operating environment. Chapter 2 Software Processes51

52. RUP 6 Best Practices  Iterative development  Prioritized phases.  Manage requirements  Document requirements.  Use component-based architectures  Structure the system to be reusable. Chapter 2 Software Processes52

53. RUP 6 Best Practices (continued)  Visually model software  UML.  Verify software quality  Control changes to software  change management system tools Chapter 2 Software Processes53

54. Discussion Chapter 2 Software Processes54