Evolutionary Prototyping's Interactions with Other Practices
by Steve McConnell
Rapid Development: Taming Wild Software Schedules
- Rapid Development: Taming Wild Software Schedules
- Preface
- I. EFFICIENT DEVELOPMENT
- 1. Welcome to Rapid Development
- 2. Rapid-Development Strategy
- 3. Classic Mistakes
- 4. Software-Development Fundamentals
- 5. Risk Management
- II. RAPID DEVELOPMENT
- 6. Core Issues in Rapid Development
- 7. Lifecycle Planning
- 8. Estimation
- The Software-Estimation Story
- Estimation-Process Overview
- Size Estimation
- Effort Estimation
- Schedule Estimation
- Estimate Refinement
- Further Reading
- 9. Scheduling
- 10. Customer-Oriented Development
- 11. Motivation
- 12. Teamwork
- Software Uses of Teamwork
- Teamwork's Importance to Rapid Development
- Creating a High-Performance Team
- Shared, Elevating Vision or Goal
- Sense of Team Identity
- Results-Driven Structure
- Competent Team Members
- Commitment to the Team
- Mutual Trust
- Interdependence Among Members
- Effective Communication
- Sense of Autonomy
- Sense of Empowerment
- Small Team Size
- High Level of Enjoyment
- How to Manage a High-Performance Team
- Why Teams Fail
- Long-Term Teambuilding
- Summary of Teamwork Guidelines
- Further Reading
- 13. Team Structure
- 14. Feature-Set Control
- 15. Productivity Tools
- 16. Project Recovery
- III. BEST PRACTICES
- Introduction to Best Practices
- 17. Change Board
- 18. Daily Build and Smoke Test
- Using the Daily Build and Smoke Test
- Managing the Risks of the Daily Build and Smoke Test
- Side Effects of the Daily Build and Smoke Test
- The Daily Build and Smoke Test's Interactions with Other Practices
- The Bottom Line on the Daily Build and Smoke Test
- Keys to Success in Using the Daily Build and Smoke Test
- Further Reading
- 19. Designing for Change
- 20. Evolutionary Delivery
- 21. Evolutionary Prototyping
- 22. Goal Setting
- 23. Inspections
- 24. Joint Application Development (JAD)
- 25. Lifecycle Model Selection
- 26. Measurement
- 27. Miniature Milestones
- 28. Outsourcing
- 29. Principled Negotiation
- 30. Productivity Environments
- 31. Rapid-Development Languages (RDLs)
- 32. Requirements Scrubbing
- 33. Reuse
- 34. Signing Up
- 35. Spiral Lifecycle Model
- 36. Staged Delivery
- 37. Theory-W Management
- 38. Throwaway Prototyping
- 39. Timebox Development
- 40. Tools Group
- 41. Top-10 Risks List
- 42. User-Interface Prototyping
- Using User-Interface Prototyping
- Managing the Risks of User-Interface Prototyping
- Side Effects of User-Interface Prototyping
- User-Interface Prototyping's Interactions with Other Practices
- The Bottom Line on User-Interface Prototyping
- Keys to Success in Using User-Interface Prototyping
- Further Reading
- 43. Voluntary Overtime
- A. Bibliography
- Index
Evolutionary Prototyping is an effective remedy for feature creep when it is used with other practices. One study found that the combination of prototyping and JAD (Chapter 24) was capable of keeping creeping requirements below 5 percent. Average projects experience levels of about 25 percent (Jones 1994).
Evolutionary Prototyping is also an effective defect-removal practice when combined with other practices. A combination of reviews, inspections, and testing produce a defect-removal strategy with the highest defect-removal efficacy, lowest cost, and shortest schedule. Adding prototyping to the mix produces a defect-removal strategy with the highest cumulative defect-removal efficacy (Pfleeger 1994a).
If Evolutionary Prototyping provides less control than you need or you already know fundamentally what you want the system to do, you can use Evolutionary Delivery (Chapter 20) or Staged Delivery (Chapter 36) instead.
On small systems, Evolutionary Prototyping is preferable to Throwaway Prototyping because the overhead of creating a throwaway prototype makes it economically unfeasible. If you're considering developing a throwaway prototype on a small-to-medium–size project, be sure that you can recoup the overhead over the life of the project.
On large systems (systems with more than 100,000 lines of code), you can use either Throwaway Prototyping or Evolutionary Prototyping. Developers are sometimes leery of using Evolutionary Prototyping on large systems, but the published reports on the use of Evolutionary Prototyping on large systems have all reported success (Gordon and Bieman 1995).
-
No Comment