Software Engineering for Students A Programming Approach
Software Engineering for Students A Programming Approach Software Engineering for Students A Programming Approach
Stage Input Output 21.3 Feedback between stages 293 requirements engineering none requirements specification architectural design requirements specification architectural design detailed design architectural design module specifications coding module specifications coding unit testing coding tested modules system testing tested modules tested system acceptance tested system satisfied client SELF-TEST QUESTION 21.2 Someone enhances the waterfall model by including a user interface design stage immediately after the requirements engineering stage. What are its inputs and outputs? 21.3 ● Feedback between stages One of the drawbacks of a strict waterfall model is that the water cannot flow upwards – if a problem is found at a particular stage in development, there is no way of redoing an earlier stage in order to rectify the problem. For example, testing usually finds errors in the (preceding) coding stage, but in the strict waterfall approach, the coding cannot be corrected. When preparing a meal, if you find that some ingredient is missing when you get to the stage of cooking the vegetables, you need to go back to the shopping stage. To overcome this obvious drawback, a variation of the waterfall model provides for feedback between adjoining stages, so that a problem uncovered at one stage can cause remedial action to be taken at the previous stage. Thus the waterfall model with feedback between stages is as shown in Figure 21.2. You will see, however, that this approach only provides for feedback to the immediately preceding step. But, in reality, any step may necessitate changes in any of the preceding stages. For example: ■ during system testing, an architectural design fault is revealed ■ during user acceptance, a problem with the specification becomes evident. So the reality of using the waterfall model is that development does not proceed in one direction, step by step. Instead, there is commonly frequent feedback to earlier stages, requiring rework (which can seriously disrupt the timescale of a project). To be more realistic, Figure 21.2 should show arrows leading backwards from every activity to every preceding activity. This, of course, undermines the model and any planning.
294 Chapter 21 ■ The waterfall model Requirements Engineering The instigators of the waterfall model clearly and wrongly perceived software development to be simple and straightforward, with development proceeding smoothly onwards from stage to stage without disruption. But, as we have seen, there are fundamental problems with using the waterfall model as a basis for a project plan. Nonetheless, it is common to use this process model. 21.4 ● Discussion Architectural design Detailed design The strengths of the waterfall model are: Coding Figure 21.2 Modified waterfall model with feedback ■ it divides a complex task into smaller, more manageable tasks ■ each task produces a well-defined deliverable. Unit testing System testing Acceptance Thus the process is well-defined. Anyone can see exactly what has been completed and what remains to be done. Perhaps the most serious problem with the waterfall model is that the client only gets to see the product at the very end of the development – and if it is not what they want, it is too late! The problem is the huge gap between requirements analysis at an early stage in a project and acceptance testing near the end. There is no opportunity to validate the user requirements at an early stage in development. This is a major problem with the waterfall model. But there are also less obvious, but equally important drawbacks. If a problem is discovered at any stage which reveals a mistake at an earlier stage, nothing can be done about it.
- Page 265 and 266: 242 Chapter 17 ■ Software robustn
- Page 267 and 268: 244 Chapter 17 ■ Software robustn
- Page 269 and 270: 246 Chapter 17 ■ Software robustn
- Page 271 and 272: 248 Chapter 17 ■ Software robustn
- Page 273 and 274: 250 Chapter 17 ■ Software robustn
- Page 275 and 276: 252 Chapter 17 ■ Software robustn
- Page 277 and 278: 254 Chapter 17 ■ Software robustn
- Page 279 and 280: 256 Chapter 17 ■ Software robustn
- Page 281 and 282: 258 Chapter 17 ■ Software robustn
- Page 283 and 284: 260 Chapter 18 ■ Scripting GNU/Li
- Page 285 and 286: 262 Chapter 18 ■ Scripting In sum
- Page 288: PART D VERIFICATION
- Page 291 and 292: 268 Chapter 19 ■ Testing We begin
- Page 293 and 294: 270 Chapter 19 ■ Testing within a
- Page 295 and 296: 272 Chapter 19 ■ Testing Test num
- Page 297 and 298: 274 Chapter 19 ■ Testing if (a >=
- Page 299 and 300: 276 Chapter 19 ■ Testing 3. apply
- Page 301 and 302: 278 Chapter 19 ■ Testing made con
- Page 303 and 304: 280 Chapter 19 ■ Testing 19.3 Dev
- Page 305 and 306: 282 Chapter 19 ■ Testing 19.2 The
- Page 307 and 308: 284 Chapter 20 ■ Groups The term
- Page 309 and 310: 286 Chapter 20 ■ Groups Of course
- Page 311 and 312: 288 Chapter 20 ■ Groups • Exerc
- Page 314 and 315: CHAPTER 21 This chapter explains: 2
- Page 318 and 319: Summary The essence and the strengt
- Page 320 and 321: CHAPTER 22 This chapter: 22.1 ● I
- Page 322 and 323: 22.2 The spiral model 299 to try to
- Page 324 and 325: 22.4 ● Discussion Exercises 301 A
- Page 326 and 327: CHAPTER 23 Prototyping This chapter
- Page 328 and 329: Therefore, in summary: ■ the prod
- Page 330 and 331: 23.5 Evolutionary prototyping 307 U
- Page 332 and 333: Reuse components 23.6 Rapid prototy
- Page 334 and 335: Pitfalls For users, the problems of
- Page 336 and 337: Answers to self-test questions 313
- Page 338 and 339: 24.2 ● Big-bang implementation 24
- Page 340 and 341: Tested component Figure 24.1 Top-do
- Page 342 and 343: 24.7 ● Use case driven implementa
- Page 344 and 345: ■ middle-out ■ use case based.
- Page 346 and 347: SELF-TEST QUESTION 25.1 What is the
- Page 348 and 349: sharing of software or their own re
- Page 350 and 351: Summary 327 Inappropriate patches,
- Page 352 and 353: Further reading 329 Cathedral and t
- Page 354 and 355: These are qualified by the statemen
- Page 356 and 357: 26.3 Extreme programming 333 develo
- Page 358 and 359: SELF-TEST QUESTION 26.3 Which of th
- Page 360 and 361: CHAPTER 27 This chapter explains:
- Page 362 and 363: Figure 27.1 The phases of the unifi
- Page 364 and 365: 27.5 ● Iteration 27.6 Case study
Stage Input Output<br />
21.3 Feedback between stages 293<br />
requirements engineering none requirements specification<br />
architectural design requirements specification architectural design<br />
detailed design architectural design module specifications<br />
coding module specifications coding<br />
unit testing coding tested modules<br />
system testing tested modules tested system<br />
acceptance tested system satisfied client<br />
SELF-TEST QUESTION<br />
21.2 Someone enhances the waterfall model by including a user interface<br />
design stage immediately after the requirements engineering stage.<br />
What are its inputs and outputs?<br />
21.3 ● Feedback between stages<br />
One of the drawbacks of a strict waterfall model is that the water cannot flow upwards –<br />
if a problem is found at a particular stage in development, there is no way of redoing an<br />
earlier stage in order to rectify the problem. For example, testing usually finds errors in<br />
the (preceding) coding stage, but in the strict waterfall approach, the coding cannot be<br />
corrected. When preparing a meal, if you find that some ingredient is missing when you<br />
get to the stage of cooking the vegetables, you need to go back to the shopping stage.<br />
To overcome this obvious drawback, a variation of the waterfall model provides <strong>for</strong><br />
feedback between adjoining stages, so that a problem uncovered at one stage can cause<br />
remedial action to be taken at the previous stage. Thus the waterfall model with feedback<br />
between stages is as shown in Figure 21.2.<br />
You will see, however, that this approach only provides <strong>for</strong> feedback to the immediately<br />
preceding step. But, in reality, any step may necessitate changes in any of the preceding<br />
stages. For example:<br />
■ during system testing, an architectural design fault is revealed<br />
■ during user acceptance, a problem with the specification becomes evident.<br />
So the reality of using the waterfall model is that development does not proceed in<br />
one direction, step by step. Instead, there is commonly frequent feedback to earlier<br />
stages, requiring rework (which can seriously disrupt the timescale of a project). To be<br />
more realistic, Figure 21.2 should show arrows leading backwards from every activity<br />
to every preceding activity. This, of course, undermines the model and any planning.