1. Alternate Software Development Methodologies
Software Engineering Process - II
Unit 5:
Alternate Software Development Methodologies

2. Before You Begin…
What are your expectations from this unit?

3. Unit Objectives Describe rapid software development approaches.
Explain incremental and iterative software development.
Identify the advantages and disadvantages of incremental development.
Explain the principles of agile development methods.
Explain the features of extreme programming and its practices and benefits.
Explain the use of software prototyping.

4. Why Rapid Software Development (RSD)
There are many reasons to use RSD. Some of them include:
Businesses have to respond to new opportunities.
It is impossible to specify the complete requirements.
As the requirements change, the system design has to be reworked.
RSD processes can produce useful software quickly.
Start the class by asking students to recall the main features of traditional approaches. For example, in waterfall method, a lot of emphasis is given on developing proper documentation at each stage and the phases are sequential. The project lifecycle is long and it may take years before a system is implemented.
Use the given points to explain why the need was felt for RSD methods.

5. Characteristics of RSD
Some characteristics of RSD include:
Specification, design, and implementation are concurrent.
The design documentation is minimum or generated automatically.
The requirements specifications describe the major requirements of the system, and must be complete for each program increment.
Explain that RSD is an iterative process, where specification, design, development, and testing are interleaved. The software is developed in the form of increments. Each increment includes new functionality.

6. Characteristics of RSD (cont.)
Software is developed in a series of increments.
Changes and new requirements that emerge on evaluation of increments are included in later versions.
User interface is developed using an interactive development system.

7. Incremental Development
Involves delivery of system in the form of increments.
Delivers the important functionality first.
Ensures that customer gets value from the system in the initial stages of development.
Facilitates the use of first increment for requirements evaluation.
Increases the probability of meeting customer requirements.
Ensures commitment from users.

8. RAD – An Iterative Development Process
Explain that RAD processes focus on architecture design in the beginning. If the solution architecture is not well designed, the resultant product may be unstable and of poor quality as the changes are introduced.

9. Class Activity - 1
Discuss and list the limitations of incremental development.
You can divide the class into five groups for this activity. Then, present a list to the class by combining points from each group.
Use the next slide to display the limitations.

10. Limitations of Incremental Development
For large systems, process models that generate regular deliverables are preferred to assess progress easily.
Incremental development may require new tools and skills to ensure quick delivery.
It may be difficult to design a satisfactory contract for lack of formal system specification.
Independent validation is difficult as the specification and development is interleaved.
Continuous changes may corrupt the structure of the software.
Finding maintenance people for specialized RAD tools may become difficult in future.
Incremental development is not suitable for some types of systems:
Large systems, which have to be implemented at multiple locations. Different types of users may require different functionality. It may become difficult to control changes.
Embedded systems in which the software development largely depends on the development of hardware.
Critical systems where it is necessary to understand and analyze all the system requirements in the beginning so that the safety and security can be assured.

11. Prototyping in Large/Critical Systems
A prototype can be used to explore requirements and experiment with design solutions.
With experience, you can have confidence that client requirements are being met.
Prototype is not intended for deployment but for generating common understanding.
You can explain that for large systems, traditional methods such as waterfall are more suitable because it is easier to assess the progress. But, you can still use a hybrid process where prototypes are made iteratively to experiment.

12. Prototyping and Incremental Development
In incremental approach, the best understood requirements are implemented first.
The architectural structure has to be robust and easy to maintain for years.
Throw-away prototyping is used to understand the vague set of requirements.
Throw-away prototypes need not be maintainable and reliable.
Emphasize on the difference between incremental approach and throw-away prototyping in terms of objectives. The evolutionary prototypes are used as a synonym for incremental software development where the prototype is not discarded but it evolves to meet customer’s requirements.

13. Agile Methods
For small and medium-sized business systems, traditional methods may not be suitable because the overheads involved are high.
Agile methods focus on software by using an iterative development process for specification, development, and delivery.
Agile methods support business development where the requirements change rapidly.
The main aim of agile methods is to deliver the working software quickly to customers.
1. The best known agile method is extreme programming, which is discussed a little later.

14. Agile Methods - Principles
Customer involvement
Incremental delivery
People not process
Accommodate change
Maintain simplicity
You can use the following information to explain these concepts:
Customer involvement: Customers have to provide requirements and evaluate each iteration. They also have to prioritize the requirements.
Incremental delivery: The software is developed in the form of increments and includes requirements as specified by the customer.
People not process: The stress is on exploiting the skills of the development team. People should follow their own ways instead of working according to any defined process. The emphasis is on pair programming, which means that two persons work on a program checking each other’s job and always aim to do a good job.
Accommodate change: System should be designed to accommodate requirement changes.
Maintain simplicity: The system and the development process should be simple. The team has to work toward reducing the complexities wherever possible.

15. Class Activity - 2
Discuss and list the problems in implementing the principles of agile methods.
Some of the problems are:
Customer have their own business tasks to perform, and may not be available for the development team.
Requirement prioritization may become difficult if there are different types of users of the system, as they may have their own priority.
Individual team members may not interact with other team members and, therefore, the expected results from pair programming may not show.
If the delivery schedules are tight, the team may not have time to put extra effort on simplifications.
System specification is done incrementally, so it may be difficult to frame contracts in the beginning.
You can conclude that agile methods are appropriate for small and medium-sized business systems. They are not suitable for large-scale or critical-system development.

16. Extreme Programming (XP)
Features of XP include:
Good practices like iterative development and customer involvement are used to extreme levels.
Requirements are given as user stories and are implemented as tasks.
Programmers work in pairs and develop test before starting development of a task.
Tests are executed before a new task is integrated into the system.
Gap between each release is short.
You can use the example given on page 401 of Software Engineering, Figure 17.6 to explain the concept of user story.

17. Extreme Programming (XP)
Explain each phase of extreme programming and relate it to the features given on the previous slide.

18. XP Practices Incremental planning Small releases Simple design
Test-first development
Refactoring
Pair programming
Collective ownership
Continuous integration
Sustainable pace
On-site customer
Use the descriptions given in Figure 17.5 on page 400 of Software Engineering to explain the concepts.
Emphasize that extreme programming takes an extreme approach to iterative development. Some unique features of XP are as follows:
Changes are incorporated and new versions are developed several times a day.
Increments are released every two weeks.
The team looks for constant improvements to code which is known as refactoring.

19. Testing in XP The features of testing process are:
Test-first development
Scenario-based incremental test development
User involvement in test development and validation
Use of automated test harnesses
Explain that the major difference between iterative system development and plan-based development is in the way the system is tested.
In iterative development, there is no system specification which can be used by an external team to test the system. Some iterative approaches have a very informal testing process. XP takes care of this problem by emphasizing test-first development, so it reduces the probability that the new system increments will introduce errors in the existing system.

20. Testing in XP (cont.)
Test-first development is one of the most important innovation of XP.
Writing test first, defines the interface and the functionality behavior.
Problems of requirement misunderstanding are minimized.
Scenario-based requirements are broken down into tasks. Each task describes a discrete feature of the system and one or more unit tests are designed for the task.
You can use the task cards and test case given on page 403, Figure 17.7 and 17.8 of Software Engineering for explaining the concepts given on this and the next slide.

21. Testing in XP (cont.)
Acceptance testing by the customer is incremental.
The customer helps in developing acceptance tests for the next release.
Testing is automated and the testing component is stand-alone. It simulates the submission of input and checks for the output as specified.

22. Pair Programming - Implementation
Programmers work in pairs to develop the software.
It does not always involve same pair of people.
Pairs are created dynamically.
All team members get to work with others.

23. Pair Programming – Advantages
Helps develop common ownership and responsibility for the system.
Supports discussion of the working of software before starting development so there are fewer false starts and less rework.
Works as inexpensive informal review process as each line of code is checked by two people.
Helps code improvement through refactoring.
Explain refactoring using the next slide.

24. Refactoring
Refactoring is a technique for restructuring an existing body of code.
It aims to alter the program’s internal structure without changing its external behavior.
Issues with refactoring can be:
A sequence of transformations can result in significant restructuring.
Each small transformation is less likely to go wrong.
The system needs to be kept working after each small refactoring.
Refactoring means that parts of code should be rewritten to improve clarity and to improvise structure.
In a normal working environment, people who practice this may be judged to be less efficient as it involves extra effort. In XP, as the goal is toward a collective ownership, everyone gains from this.

25. Class Activity - 3
Explain how the practices of XP fit into the principles of agile methods.
You could ask the students to do this activity in groups of two. You can refer to page 400, Figure 17.5 of Software Engineering for doing this activity. The solution can be given in the form of a mapping table.

26. RAD RAD: Evolved from fourth-generation languages in the 80s.
Used for business applications that are data intensive.
Organized as a set of tools that help to create, search, display, and present data using different formats.
Provides powerful facilities for screen definition and report generation.
You can tell the students that Visual Basic developed by Microsoft is a good example of a RAD tool. It includes tools that allow the system to be developed interactively. Programmers define the interface in terms of screens, fields, buttons, and menus. Processing scripts can be associated with any of these. For example, a button named Add may contain script for validating and adding data to the database table(s).

27. RAD (cont.)

28. RAD – Screen Generation
Screen generation facility of a RAD tool must provide for:
Interactive form definition, where the developer defines the fields and their organization on the form.
Form linking, where the developer defines which field invokes a subsequent form.
Field verification, where the developer defines the applicable value ranges or the data types.

29. RAD – Advantages and Limitations
Enables quick development of simple applications with small teams.
Implements a lot of functionality at a very low cost.
Users familiar with the technology do not have to learn new features.
Limitations:
No explicit system architecture and dependencies between parts of system.
Difficult to implement nonstandard user interfaces.

30. Software Prototyping
A software prototype is an initial version of a software system and can be used to get some benefits of the incremental development process.
It helps:
Demonstrate concepts
Try out design options
Explore more about the problem and possible solutions

31. Software Prototyping Software prototypes can be used to:
Elicit and validate requirements.
Explore software solutions and to support user interface design.
Run back-to-back tests with the final system that will be delivered to the customer.
Explain each point by using the information given on pages of Software Engineering.

32. Prototype Development Process

33. Advantages of Prototyping
Improved system usability
More likelihood of meeting customer requirements
Improved design quality
Improved maintainability
Reduced development effort

34. Summary
What was your key learning from the unit?