1. Teaching material for a course in Software Project Management & Software Engineering – part II

2. Part 2: Software Lifecycle Management Chapter 9 (Introduction to software lifecycle management) Software lifecycle is a series of processes which are used to build software products. These are also termed software lifecycle models. The main software lifecycle models include waterfall model and many varieties of iterative models like SCRUM, eXtreme Programming etc. Waterfall model is the classic model for software development where each development process follows the preceding process without the room to go back like a waterfall where water falls from top and goes down without ever coming back to the top. Software building starts when requirement gathering is done. From requirements, a software design is made. From software design, software construction starts.

3. Part 2: Software Lifecycle Management Chapter 9 (Introduction to software lifecycle management) Benefits in terms of productivity gains of Software engineering

4. Part 2: Software Lifecycle Management Chapter 9 (Introduction to software lifecycle management) Software lifecycle in waterfall model

5. Part 2: Software Lifecycle Management Chapter 9 (Introduction to software lifecycle management) Contrary to waterfall model, iterative models allow the software building work to go back so that any part of the software can be rebuilt using rework. Models like SCRUM and eXtreme programming in fact try to minimize the rework by using iterations. In one iteration, small set of features of the software product are taken and they are completely built in a short period of time; say one week. Once it is reviewed and okayed, next set of features are taken. This way, the complete software product is built over a long period of time. Iterative models differ from each other by the degree to which the iteration takes place. In SCRUM model, the iteration is complete

6. Part 2: Software Lifecycle Management Chapter 9 (Introduction to software lifecycle management) concurrent engineering in Software lifecycle

7. Part 2: Software Lifecycle Management Chapter 9 (Introduction to software lifecycle management) Work products from software lifecycle stages

8. Part 2: Software Lifecycle Management Chapter 9 (Introduction to software lifecycle management) Quality gates for developing a better software product

9. Part 2: Software Lifecycle Management Chapter 9 (Introduction to software lifecycle management) Waterfall model poses significant risk in terms of rework which may have to be done when requirements get changed (which is often). The iterative models offer attractive benefits in this regard. Most of the software projects where products are built for newer technology like those for social media, software for gadgets like mobiles, cameras etc. iterative models are better suited. Due to increased pace with which technology gets obsolete and newer technology takes its place, iterative models allow the project teams to incorporate newer technology (changed requirements) with ease. However waterfall model is still better suited for products where a massive backbone is needed to build a software product. Software applications for businesses like Enterprise Resource Planning (ERP), computer operating systems etc. are such examples. The base design for these products are indeed massive in size and thus iterative models do suite to build such products.

10. Part 2: Software Lifecycle Management Chapter 10 (Requirement Management) Requirement gathering is the process of interacting with end users and take their requirements. These requirements are then analyzed and a systematic set of requirements is built. One important aspect about requirement management is that whenever there is a change in any requirement, it should be recorded immediately and subsequent processes of design and construction should be able to incorporate the changes with minimal rework.

11. Part 2: Software Lifecycle Management Chapter 10 (requirement management) Software requirement types

12. Part 2: Software Lifecycle Management Chapter 10 (requirement management) Non functional Software requirement types

13. Part 2: Software Lifecycle Management Chapter 10 (requirement management) Software requirement levels

14. Part 2: Software Lifecycle Management Chapter 10 (requirement management) Source of Software requirements

15. Part 2: Software Lifecycle Management Chapter 10 (requirement management) Software requirements process cycle

16. Part 2: Software Lifecycle Management Chapter 10 (requirement management) Software requirements change management cycle

17. Part 2: Software Lifecycle Management Chapter 10 (requirement management) Software requirements validation cycle

18. Part 2: Software Lifecycle Management Chapter 10 (requirement management) Software requirements validation cycle in iterative models

19. Part 2: Software Lifecycle Management Chapter 11 (Software Design management) Software design is the process where the software architecture is built and refined using the end user requirements. In the waterfall model, the software product will have a large number of parts which can be designed separately from each other and later can be joined. If you need to break the software product design into many parts then you can use either top down approach or bottom up approach. In top down approach, the software design for the entire product is built first and later its parts are designed. In bottom up approach, the software product parts are designed first and later they are joined to create design of the entire product. With each change request there will be a different version of the software design. Maintaining these design versions through the development process is very important. You have to make sure that the right design is used for software construction. Software design should be robust and should also be able to take change requests without any problems. When a software product is incrementally built then the later versions of the software design should be fully compatible with the original software design. There are many software design techniques available to make appropriate software designs for the product being built. They include prototyping, structural models, object oriented design, entity relationship models etc. Refactoring is a design technique which is used in iterative models. When the design become bulky after many iterations of development, it starts getting crumbling against new features being added to the product. In such cases, the design is changed so that new factors of the features being added are incorporated.

20. Part 2: Software Lifecycle Management Chapter 11 (design management) Characteristics of a good software design

21. Part 2: Software Lifecycle Management Chapter 11 (design management) software design using top to bottom method

22. Part 2: Software Lifecycle Management Chapter 11 (design management) software design using bottom up method

23. Part 2: Software Lifecycle Management Chapter 11 (design management) software design techniques

24. Part 2: Software Lifecycle Management Chapter 11 (design management) Cases when software refactoring (re-design) needed

25. Part 2: Software Lifecycle Management Chapter 12 (software construction management) Software construction must be started with some standards in software coding. Without a proper standard through various parts of the construction, software defects will be injected. Coding standard should include factors like variable naming conventions, coding structure patterns, modularity, reliability, safety, maintainability etc. Programming language should be carefully selected so that it meets the coding requirements. code reviews should be done whenever a feature is built. Review should ensure that the quality norms are met and software defects are eliminated whenever they are encountered. There are many coding methods available which have evolved over time. They include structural programming, object oriented programming, pair programming, test driven development etc. Configuration management for software construction should be done carefully. Branching of code should be decided carefully so that there not many unnecessary branches of the code should exist and at the same time the software code for required number of software versions are available. Testing of the source code should be thoroughly done both at unit level and at integration level.

26. Part 2: Software Lifecycle Management Chapter 12 (construction management) Conversion of software design into software product

27. Part 2: Software Lifecycle Management Chapter 12 (construction management) Required construction characteristics for a good software product

28. Part 2: Software Lifecycle Management Chapter 12 (construction management) Software construction verification cycle

29. Part 2: Software Lifecycle Management Chapter 12 (construction management) Software code reuse techniques

30. Part 2: Software Lifecycle Management Chapter 12 (construction management) When Unit testing required?

31. Part 2: Software Lifecycle Management Chapter 12 (construction management) Quality techniques for construction in iterative model

32. Part 2: Software Lifecycle Management Chapter 12 (construction management) Example of complete workflow of construction with configuration management

33. Part 2: Software Lifecycle Management Chapter 13 (software testing management) Traditionally Software testing has been often a neglected area as managements used to see it as a waste of dollars spent (no productive output in terms of something produced). However with strict quality norms required these days for software products, software testing is one of the important aspects on software projects. Software testing involves validating a software product by comparing expected behavior with the actual behavior when tested. Verification of the software code on the other hand involves doing inspection to verify that the software code written correctly or not. A separate plan for testing is prepared to ensure that proper testing is done on the project. The testing plan should include test strategy, resource planning, budget and schedule.

34. Part 2: Software Lifecycle Management Chapter 13 (testing management) Considerations for software testing effort required

35. Part 2: Software Lifecycle Management Chapter 13 (testing management) Drawback of late software testing in development lifecycle

36. Part 2: Software Lifecycle Management Chapter 13 (testing management) Verification & validation on software projects

37. Part 2: Software Lifecycle Management Chapter 13 (testing management) software testing effort estimation

38. Part 2: Software Lifecycle Management Chapter 13 (testing management) software testing – test case lifecycle

39. Part 2: Software Lifecycle Management Chapter 13 (testing management) software testing – defect lifecycle

40. Part 2: Software Lifecycle Management Chapter 13 (software testing management) Test automation is a good resource to reduce software testing effort. But all testing activities can not be automated. Testing activities include test case writing, test case execution, test case result analysis etc. Test case writing can be automated for unit testing but for other types of testing (integration testing, user acceptance testing etc.), automation is difficult and so manual test case writing is done. The first time a test case is run should be done manually and so it can not be automated. The only area open for automation is repeated test case execution. So when same test cases need to be executed many times then those test cases should be automated. On what kind of projects, this scenario exists? On iterative projects, the newer versions of the product (with new functionality added) need to be tested for both new functionality added as well as the older functionality. In such cases, the test cases written for older features can be rerun on newer versions of the product. On such projects, test execution can be automated.

41. Part 2: Software Lifecycle Management Chapter 13 (software testing management) Software defect tracking is one area which needs attention to know which parts of the software product are failing again and again. Defect tracking is important because it shows the testing effort in terms of number of defects found, defects corrected and still open defects.

42. Part 2: Software Lifecycle Management Chapter 14 (software release & maintenance) Software lifecycle ends when the software product is released for production. Software maintenance in production can be considered another area separately if it is done independently from software development cycle. But on modern software development projects, where iterative models are utilized, software maintenance co-exists with software development. The activities during product release include end user training, product implementation, user manual preparation etc. Last minute product changes sometimes also take place. Software product maintenance has its own lifecycle. Periodic maintenance plans are prepared and defects are removed during those periods using software patches. Software maintenance can be of type preventive, corrective, and adaptive. Maintenance techniques include re-egineering, reverse engineering, and forward engineering.

43. Part 2: Software Lifecycle Management Chapter 14 (release management) Product release management tasks

44. Part 2: Software Lifecycle Management Chapter 14 (release management) Product release types

45. Part 2: Software Lifecycle Management Chapter 14 (release management) Product implementation tasks

46. Part 2: Software Lifecycle Management Chapter 14 (release management) Product maintenance financial considerations

47. Part 2: Software Lifecycle Management Chapter 14 (release management) Software maintenance process models

48. Part 2: Software Lifecycle Management Chapter 14 (release management) Software maintenance lifecycle

49. Part 2: Software Lifecycle Management Chapter 14 (release management) Software maintenance engineering techniques