Software Engineering for Students A Programming Approach
Software Engineering for Students A Programming Approach Software Engineering for Students A Programming Approach
20.3 Structured walkthroughs 285 Although structured walkthroughs were initially used to find bugs in program code, the technique is valuable for reviewing the products at every stage of development – the requirements specification, a software specification, architectural design, component design, the code, the test data, the results of testing, the documentation. There are several key points in organizing walkthroughs successfully: ■ gauge the size and membership of the group carefully so that there are plenty of ideas, but so that everyone is fully involved ■ expect participants to study the material prior to the meeting ■ concentrate attention on the product rather than the person, to avoid criticizing the author ■ limit the length of the meeting, so that everyone knows that it is business-like ■ control the meeting with the aid of agreed rules and an assertive chairperson ■ restrict the activity to identifying problems, not solving them ■ briefly document the faults (not the cures) for later reference. The benefits of structured walkthroughs can be: 1. software quality is improved because ■ more bugs are eliminated ■ the software is easier to maintain, because it is clearer 2. programmer effort is reduced because ■ specifications are clarified before implementation ■ errors are detected early, and so costly rework is avoided ■ the time spent at the meeting (and in preparation for it) is more than repaid in time saved 3. meeting deadlines is improved because ■ visibility of the project is better (so potential catastrophes are prevented) ■ major errors are avoided early 4. programmer expertise is enhanced because ■ everyone learns from everyone else 5. programmer morale is improved because ■ people gain satisfaction from better work ■ people get to find out what is going on ■ people enjoy the discussions with colleagues.
286 Chapter 20 ■ Groups Of course walkthroughs do mean that the individual has to be relaxed about presenting their work to colleagues. 20.4 ● Inspections These are similar to structured walkthroughs – a group of people meet to review a piece of work. But they are different from walkthroughs in several respects. Checklists are used to ensure that no relevant considerations are ignored. Errors that are discovered are classified according to type and carefully recorded on forms. Statistics on errors are computed, for example in terms of errors per 1,000 lines of code. Thus inspections are not just well organized, they are completely formal. In addition management is informed of the results of inspections, though usually they do not attend the meeting. Thus inspections are potentially more threatening to the programmer than walkthroughs. There are other, minor, differences between inspections and walkthroughs. Normally there are only four members in an inspection team: ■ the moderator, who co-ordinates activities ■ the person who designed the program component being inspected ■ the programmer ■ the tester – a person who acts as someone who will be responsible for testing the component. The essence of inspections is that the study of products is carried out under close management supervision. Thus inspections are overtly a mechanism for increased control over programmers’ work, similar to the way that quality control is carried out on a factory floor. Some programmers might feel threatened in this situation and become defensive, perhaps trying to hide their mistakes. Perhaps this makes the discovery of errors more painful, and programming a less enjoyable activity. From an organizational point of view, keeping records of faults discovered during inspections provides information to predict the quality of the software being written. Also, by highlighting common mistakes it can be used to improve programmers selfawareness and thereby improve their skills. 20.5 ● Pair programming Here two people sit down together, looking at the same computer screen, and carry out programming, including writing and applying tests. The people have different roles. One has the use of the keyboard and mouse. They are thinking and working on the implementation of the current piece of code (usually a particular method). They are thinking on a small scale and locally. The other person does two things: ■ observe, looking for errors ■ think more strategically.
- Page 257 and 258: 234 Chapter 16 ■ Programming in t
- Page 259 and 260: 236 Chapter 16 ■ Programming in t
- Page 261 and 262: 238 Chapter 17 ■ Software robustn
- Page 263 and 264: 240 Chapter 17 ■ Software robustn
- 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: 284 Chapter 20 ■ Groups The term
- Page 311 and 312: 288 Chapter 20 ■ Groups • Exerc
- Page 314 and 315: CHAPTER 21 This chapter explains: 2
- Page 316 and 317: Stage Input Output 21.3 Feedback be
- 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
20.3 Structured walkthroughs 285<br />
Although structured walkthroughs were initially used to find bugs in program code,<br />
the technique is valuable <strong>for</strong> reviewing the products at every stage of development – the<br />
requirements specification, a software specification, architectural design, component<br />
design, the code, the test data, the results of testing, the documentation.<br />
There are several key points in organizing walkthroughs successfully:<br />
■ gauge the size and membership of the group carefully so that there are plenty of<br />
ideas, but so that everyone is fully involved<br />
■ expect participants to study the material prior to the meeting<br />
■ concentrate attention on the product rather than the person, to avoid criticizing the<br />
author<br />
■ limit the length of the meeting, so that everyone knows that it is business-like<br />
■ control the meeting with the aid of agreed rules and an assertive chairperson<br />
■ restrict the activity to identifying problems, not solving them<br />
■ briefly document the faults (not the cures) <strong>for</strong> later reference.<br />
The benefits of structured walkthroughs can be:<br />
1. software quality is improved because<br />
■ more bugs are eliminated<br />
■ the software is easier to maintain, because it is clearer<br />
2. programmer ef<strong>for</strong>t is reduced because<br />
■ specifications are clarified be<strong>for</strong>e implementation<br />
■ errors are detected early, and so costly rework is avoided<br />
■ the time spent at the meeting (and in preparation <strong>for</strong> it) is more than repaid in<br />
time saved<br />
3. meeting deadlines is improved because<br />
■ visibility of the project is better (so potential catastrophes are prevented)<br />
■ major errors are avoided early<br />
4. programmer expertise is enhanced because<br />
■ everyone learns from everyone else<br />
5. programmer morale is improved because<br />
■ people gain satisfaction from better work<br />
■ people get to find out what is going on<br />
■ people enjoy the discussions with colleagues.