Software Engineering for Students A Programming Approach
Software Engineering for Students A Programming Approach Software Engineering for Students A Programming Approach
28.6 The object-oriented team 353 The benefits of the chief programmer team to the organization are thus: (a) improved programmer productivity because ■ less time is spent in communication ■ each programmer is carrying out specialized work at which they are highly skilled (b) improved software quality because ■ the team is organized around a highly skilled programmer ■ the interfaces between software components are clearer ■ fewer bugs arise from communication problems because there are fewer programmers (c) meeting deadlines more reliably because ■ there is greater visibility of the project through the high technical involvement of the chief programmer. Other benefits that are cited concern career paths. Someone who is a good programmer but does not want to go into management can become a chief programmer – largely a technical role. A number of problems arise for the management of a large project. First, since any team is only manageable with up to about nine people, what do we do if a project is sufficiently large that it needs more than this number? One suggestion (but it is only that) is to start the project with a chief programmer team to carry out the high-level software design and the top-level implementation. When this is complete the original team is broken up and its members become chief programmers within the set of teams that carry out developments of the subsystems. A remnant of the original team carries out system integration and validation. Another problem of chief programmer team organization is this: the team is supposed to be made up of good experienced programmers, so how do inexperienced programmers gain expertise? Here the suggestion is that they train by doing maintenance on existing programs. 28.6 ● The object-oriented team Object-oriented development tries to achieve two objectives: ■ reuse of existing components from either the standard library or the in-house library ■ the creation of new reuseable components for the in-house library. Thus, organizations using the object-oriented paradigm have found it desirable to divide their personnel into teams of application programmers on the one hand, and teams of class or component programmers on the other. The motivation here is that the
354 Chapter 28 ■ Teams benefits of the object-oriented paradigm are only be realized if a concerted effort is made to identify reusable software components and to organize such components within an accessible library. A domain-specific class library becomes viewed as one of the major assets of the organization. Indeed, some large companies have reported that they have been able to reduce the amount of new code written on large projects by a factor of 50% through the use of such libraries. In such a scenario, application programmers are thought of as consumers; they implement application-specific classes, but are always seeking to reuse existing library components whenever possible. They seek better reusable components from the class programmers and also have a responsibility to identify useful abstractions that can be migrated from the application to the library. Class programmers (or component developers) are thought of as producers; they produce reusable components of general use to the organization. Their job is to polish, generalize, reorganize and augment library classes. Their task should not be underestimated – producing reusable components is more difficult than writing components for a specific project. In a moderate-size project the developers are divided up along class versus application lines. The architecture team contains the key designers and programmers; their responsibility is to oversee the project as a whole and also to take responsibility for critical modules of the system. They are supported by teams of subsystem developers who are responsible for the development of “large grain” subsystems. The class developers are responsible for the development of a reusable component library. This kind of approach has given rise to a plethora of new job titles and functions, for example, application directors, class managers, reuse evaluators. The key to the success of such an approach is communication between team members, particularly between the architecture/subsystem teams and the component developers. It is highly desirable to develop a culture in which team members are rewarded for producing components that have a broad applicability or design frameworks that can be reused. 28.7 ● Discussion The chief programmer team is hierarchical and tree-structured. Its organizational structure tends to produce software that has a matching structure. This may be completely appropriate for certain types of software. Indeed, much software is hierarchical in structure. Generalizing, it can be hypothesized that teams tend to produce software whose structure matches their own structure. Suppose, for example, that some software is designed by a committee, acting democratically. What would the structure of the software look like? Perhaps it would be complex, with many interactions (reflecting the many interactions between its designers) or perhaps it would display haphazard structure, without the single clear vision provided by a charismatic leader. But for certain types of software – for example, expert systems – these structures might be completely appropriate. Thus it may be that different forms of organization are appropriate for different types of software project.
- 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
- Page 366 and 367: The transition phase Summary 343 Th
- Page 368: PART F PROJECT MANAGEMENT
- Page 371 and 372: 348 Chapter 28 ■ Teams The commun
- Page 373 and 374: 350 Chapter 28 ■ Teams Level of s
- Page 375: 352 Chapter 28 ■ Teams A chief pr
- Page 379 and 380: 356 Chapter 28 ■ Teams • Furthe
- Page 381 and 382: 358 Chapter 29 ■ Software metrics
- Page 383 and 384: 360 Chapter 29 ■ Software metrics
- Page 385 and 386: 362 Chapter 29 ■ Software metrics
- Page 387 and 388: 364 Chapter 29 ■ Software metrics
- Page 389 and 390: 366 Chapter 29 ■ Software metrics
- Page 391 and 392: 368 Chapter 29 ■ Software metrics
- Page 393 and 394: CHAPTER 30 This chapter: 30.1 ● I
- Page 395 and 396: 372 Chapter 30 ■ Project manageme
- Page 397 and 398: 374 Chapter 30 ■ Project manageme
- Page 399 and 400: 376 Chapter 30 ■ Project manageme
- Page 401 and 402: 378 Chapter 30 ■ Project manageme
- Page 403 and 404: 380 Chapter 30 ■ Project manageme
- Page 405 and 406: 382 Chapter 30 ■ Project manageme
- Page 408 and 409: CHAPTER 31 This chapter: 31.1 ● I
- Page 410 and 411: 31.3 Case study - assessing verific
- Page 412 and 413: 31.5 A single development method? 3
- Page 414 and 415: Further reading 391 31.2 Draw up a
- Page 416 and 417: 32.3 ● The world of programming l
- Page 418 and 419: 32.5 ● The real world of software
- Page 420 and 421: 32.6 Control versus skill 397 Final
- Page 422 and 423: Formal methods 32.7 Future methods
- Page 424 and 425: Summary 401 In the short-term futur
28.6 The object-oriented team 353<br />
The benefits of the chief programmer team to the organization are thus:<br />
(a) improved programmer productivity because<br />
■ less time is spent in communication<br />
■ each programmer is carrying out specialized work at which they are highly<br />
skilled<br />
(b) improved software quality because<br />
■ the team is organized around a highly skilled programmer<br />
■ the interfaces between software components are clearer<br />
■ fewer bugs arise from communication problems because there are fewer programmers<br />
(c) meeting deadlines more reliably because<br />
■ there is greater visibility of the project through the high technical involvement<br />
of the chief programmer.<br />
Other benefits that are cited concern career paths. Someone who is a good programmer<br />
but does not want to go into management can become a chief programmer – largely<br />
a technical role.<br />
A number of problems arise <strong>for</strong> the management of a large project. First, since any<br />
team is only manageable with up to about nine people, what do we do if a project is<br />
sufficiently large that it needs more than this number? One suggestion (but it is only<br />
that) is to start the project with a chief programmer team to carry out the high-level<br />
software design and the top-level implementation. When this is complete the original<br />
team is broken up and its members become chief programmers within the set of teams<br />
that carry out developments of the subsystems. A remnant of the original team carries<br />
out system integration and validation.<br />
Another problem of chief programmer team organization is this: the team is supposed<br />
to be made up of good experienced programmers, so how do inexperienced programmers<br />
gain expertise? Here the suggestion is that they train by doing maintenance<br />
on existing programs.<br />
28.6 ● The object-oriented team<br />
Object-oriented development tries to achieve two objectives:<br />
■ reuse of existing components from either the standard library or the in-house library<br />
■ the creation of new reuseable components <strong>for</strong> the in-house library.<br />
Thus, organizations using the object-oriented paradigm have found it desirable to<br />
divide their personnel into teams of application programmers on the one hand, and<br />
teams of class or component programmers on the other. The motivation here is that the