Java Web Hosting, Mysql, Jsp, Servlet, Tomcat, Ssh Blog

14.2 Mid-Project: Feature-Creep Control In-house development organizations are especially susceptible to being unresponsive to their users. They quit looking at their users as true customers because they have an exclusive engagement. Friction results over time, and then the developers use the requirements specification as a weapon to force their users to behave. No one likes working in the face of a steady stream of arbitrary changes, but there are more constructive ways to respond than beating the users on the head with a requirements document. Developers who do that are finding with increasing frequency that their engagements aren’t as exclusive as they had once thought (Yourdon 1992). When the market is changing rapidly. In the 1960s, and earlier, when business needs changed more slowly than they do today, it might have been wise to plan a product in detail two years before you released it. Today, the most successful products are often those that had the most change implemented the latest in the development cycle. Rather than automatically trying to eliminate requirements changes, the software developer’s job today is to strike a balance between chaos and rigidity rejecting low-priority changes and accepting changes that represent prudent responses to changing market conditions. When you want to give latitude to the developers. One big change associated with the PC revolution has been that project sponsors are more willing to leave large parts of the specification to the developers’ discretion (for the reasons described in the “Minimal Specification” section early in this chapter). If you want to leave part of the product concept to the developers, you can’t freeze the product concept as soon as requirements specification is complete; you have to leave at least part of it open for the developers to interpret. Stable or notstable? How stable your requirements are has a huge impact on how you go about software development, and particularly on what you need to do to develop rapidly. If your requirements are stable, you develop one way. If they are unstable, you develop another way. From a rapid-development point of view, one of the worst mistakes you can make is to think your requirements are stable when they aren’t. If your project doesn’t have stable requirements, it isn’t sufficient any more to throw up your hands and shout “Yikes! We don’t have stable requirements!” and proceed the same as you would have if you did have stable requirements. You can take certain steps to compensate for unstable requirements, and you must take those steps if you want to develop rapidly.
Please visit Domain Name Hosting services for high quality webhost to host and run your jsp applications.

Chapter 14: Feature-Set Control CROSS-REFERENCE For details on this point, see Section 3.2, “Effect of Mistakes on a Development Schedule.” As you can see in Figure 14-5, both the average and maximum productivities were higher when changes were controlled, and this study suggests that it is hardly ever possible to achieve high productivity unless you control changes. At the bottom ends of the ranges, some projects had the same low productivity regardless of whether they did a good job of controlling changes. As with other effective development practices, controlling changes is not by itself sufficient to guarantee high productivity. Even when you do a good job of controlling changes, there are other ways to torpedo a project. Wisdom of Stopping Changes Altogether Requirements that don’t change are great. If you can develop software to an unchanging set of requirements, you can plan with almost 100-percent accuracy. You can design and code without wasting time to make late changes inefficiently. You can use any of the unstable-requirements practices and any of the stable-requirements practices too. The whole universe of speed-oriented development practices is open to you. Such projects are a joy to work on and a joy to manage. You can reach project completion faster and more economically than you can in any other circumstances. That’s nice work if you can get it. When you do need some flexibility, however, pretending that no changes are allowable or desirable is just a way to lose control of the change process. Here are some circumstances in which it is unwise to try to stop changes altogether. When your customers don’t know what they want. Refusing to allow changes assumes that your customers know what they want at requirements time. It assumes that you can truly know requirements at the outset, before design and coding begin. On most projects, that’s not possible. Part of the software developer’s job is to help customers figure out what they want, and customers often can’t figure out what they want until they have working software in their hands. You can use the various incremental development practices to respond to this need. When you want to be responsive to your customer. Even when you think your customers know what they want, you might want to keep the software flexible to keep your options open. If you follow a frozen-requirements plan, you might deliver the product on time, but you might seem unresponsive, and that can be just as bad as late delivery. If you’re a contract software developer, you might need to stay flexible to stay competitive. If you’re an in-house developer, your company’s well-being might depend on your providing that flexibility.
You want to have a cheap webhost for your apache application, then check apache web hosting services.

14.3 Mid-Project: Feature-Creep Control product’s feature set to achieve maximum development speed, you must make it clear that you want your team to tend toward #1. You must make it clear that development speed is the top design-and-implementation goal, and you must not confuse that goal by piling many other goals on top of it. Effects of Change People are far too casual about the effects that late changes in a project have. They underestimate the ripple effects that changes have on the project’s design, code, testing, documentation, customer support, training, configuration management, personnel assignments, management and staff communications, planning and tracking, and ultimately on the schedule, budget, and product quality (Boehm 1989). When all these factors are considered, changes typically cost anywhere from 50 to 200 times less if you make them at requirements time than if you wait until construction or maintenance (Boehm and Papaccio 1988). As I said at the beginning of the chapter, several studies have found that feature creep is the most common source of cost and schedule overruns. A study at ITT produced some interesting results in this area (Vosburgh et al. 1984). It found that projects that experienced enough change to need their specifications to be rewritten were significantly less productive than projects that didn’t need to rewrite their specs. Figure 14-5 illustrates the difference. Figure 14-5. Findings for “Changes Require Specification to Be Rewritten” factor (Vosburgh et at. 1984). Controlling changes can produce dramatic improvements in productivity, but that control does not by itself guarantee success.
We recommend cheap and reliable webhost to host and run your web applications: Coldfusion Web Hosting services.

Chapter 14: Feature-Set Control CROSS-REFERENCE For more on goal setting, see “Goal Setting” in Section 11.2. beyond the base work required to implement polymarkers would be negligible, probably on the order of a few minutes. At the high end, a variable maximum number of polymarkers have their sizes set at runtime, interactively, by the user. That calls for dynamically allocated data, a flexible dialog box, persistent storage of the polymarker sizes set by the user, extra source-code files put under version control, extra test cases, and documentation of all the above in paper documents and online help. The amount of work required to implement this would probably be measured in weeks. The amazing thing about this example is that it represents weeks of potential difference in schedule arising from a single, trivial characteristic of a charting program the size of the polymarkers. We haven’t even gotten to the possibility that polymarkers might also be allowed to have different outline colors, outline thicknesses, fill colors, orderings, and so on. Even worse, this seemingly trivial issue is likely to interact with other seemingly trivial issues in combination, meaning that you multiply their difficulties together rather than merely add them. The point of this is that the devil really is in the details, and implementation time can vary tremendously based on how developers interpret seemingly trivial details. No specification can hope to cover every one of these trivial details. Without any guidelines to the contrary, developers will pursue flexible approaches that tend more toward option #10 than #1. Most conscientious developers will intentionally try to design some flexibility into their code, and as the example illustrates, the amount of flexibility that a good developer will put into code can vary tremendously. As my friend and colleague Hank Meuret says, the programmer ideal is to be able to change one compiler switch and compile a program as a spreadsheet instead of a word processor. When you multiply the tendency to choose flexibility rather than development speed across dozens of developers and hundreds of detailed decisions on a project, it’s easy to see why some programs are vastly larger than expected and take vastly longer than expected to complete. Some studies have found up to 10-to-l differences in the sizes of programs written to the same specification (DeMarco and Lister 1989). If you were to proceed through implementation with the assumption that whenever you encountered an ambiguity in the specification you would tend toward the #1 end of the set of options rather than toward the #10 end, you could easily implement your whole program an order of magnitude faster than someone who took the opposite approach. If you want to leverage your
From our experience, we are can tell you that you can find a reliable and cheap webhost service at Java Web Hosting services.

14.2 Mid-Project: Feature-Creep Control Figure 14-4. Examples of polymarkers. Tloere can be at least a 10-to-l difference in size and implementation time of even seemingly trivial features. 4. Set up the source code to be modified in one place, on a polymarker- by-polymarker basis, for a dynamic number of polymarkers (for example, you might later want to add cross-hairs, diamonds, and bull’s-eyes to the original set of polymarkers). 5. Allow for modification of an external file that the program reads at startup, one setting for the whole set of polymarkers (tor example, an ,ini file or other external file). 6. Allow for modification of an external file that the program reads at startup, different settings for each polymarker, for a fixed number of polymarkers. 7. Allow for modification of an external file that the program reads at startup, different settings for each polymarker, for a dynamic number of polymarkers. 8. Allow for interactive, end-user modification of a single polymarker- size specification. 9. Allow for interactive, end-user modification of polymarker-size speci- fications, with one setting per polymarker, for a fixed number of polymarkers. 10. Allow for interactive, end-user modification of polymarker-size specifications, with one setting per polymarker, for a dynamic number of polymarkers. These options represent huge differences in design and implementation times. At the low end, a fixed number of polymarkers have their sizes hard- coded into the program. This requires only that polymarkers be represented in an array of fixed size. The amount of work required to implement that
If you are looking for cheap and quality webhost to host and run your website check Jboss Web Hosting services.

Chapter 14: Feature-Set Control All in all, projects tend to experience about a 1-percent change in requirements per month. On average, the longer your project takes, the more your product will change before it’s complete (Jones 1994). A few factors can make that figure considerably worse. Killer-app syndrome Shrink-wrap products are particularly susceptible to “killer-app syndrome.” The development group at Company A sets developing “the best application in its class” as its design goal. The group designs an application that meets that criteria and then begins to implement it. A few weeks before the software is scheduled to ship, Company B’s application enters the market. Their application has some features that Company A never thought of and others that are superior to Company A’s. The development group at Company A decides to slide its schedule a few months so that it can redesign its application and truly clobber Company B. It works until a few weeks before its revised ship date, and then Company C releases its software, which is again superior in some areas. The cycle begins again. Unclear or impossible goals It’s difficult to resist setting ambitious goals for a project: “We want to develop a world-class product in the shortest possible time at the lowest possible cost.” Because it isn’t possible to meet that entire set of goals or because the goals are unclear, the most likely result is meeting none of the goals. If developers can’t meet the project’s goals, they will meet their own goals instead, and you will lose much of your influence over the project’s outcome. To illustrate the way in which clear goals can have a significant effect on a development schedule, consider the design and construction of a charting program. There is a tiny part of the charting program that deals with “polymarkers” squares, circles, triangles, and stars that designate specific points on a graph. Figure 14-4 shows an example. Suppose that the specification is silent on the question of whether to provide the user with the ability to control the polymarkers’ sizes. In such a case, the developer who implements the polymarkers can provide such control in any of many ways: 1. Do not provide any control at all. 2. Set up the source code to be modified in one place for the whole set of polymarkers (that is, sizes of all polymarkers are set by a single named constant or preprocessor macro). 3. Set up the source code to be modified in one place, on a polymarkerby- polymarker basis, for a fixed number of polymarkers (that is, size of each polymarker square, triangle, and so on is set by its own named constant or preprocessor macro).
We highly recommend you visit web and email hosting services if you need stable and cheap web hosting platform for your web applications.

14.2 CROSS-REFERENCE For tips on resisting pressure, including pressure to add requirements, see Section 9.2, “Beating Schedule Pressure.” 14.2 Mid-Project: Feature-Creep Control happens, you become especially glad that you didn’t put the scrapped features into version 1. Mid-Project: Feature-Creep Control If you do a good job of specifying a lean product, you might think you have your feature set under control. Most projects aren’t that lucky. For many years, the holy grail of requirements management has been to collect a set of requirements scrubbed, minimally specified, or otherwise encase them in permafrost, and then build a complete product design, implementation, documentation, and quality assurance atop them. Unfortunately for developers and their ulcers, projects that have successfully frozen their requirements have proven to be almost as hard to find as the Holy Grail itself. A typical project experiences about a 25-percent change in requirements during development (Boehm 1981, Jones 1994). Sources of Change Mid-project changes arise from many sources. End-users want changes because they need additional functionality or different functionality or because they gain a better understanding of the system as it’s being built. Marketers want changes because they see the market as feature-driven. Software reviews contain long lists of features and check marks. If new products with new feaaires come out during a product’s development, marketers naturally want their products to stack up well against the competition, and they want the new features added to their product. Developers want changes because they have a great emotional and intellectual investment in all of the system’s details. If they’re building the second version of a system, they want to correct the first version’s deficiencies, whether such changes are required or not. Each developer has an area of special interest. It doesn’t matter whether a user interface that’s 100 percent compliant with user-interface standards is required, or whether lightning-fast response time, perfectly commented code, or a fully normalized database are specified: developers will do whatever work is needed to satisfy their special interests. All these groups end-users, marketers, and developers will try to put their favorite features into the requirements spec even if they didn’t make it during the formal requirements-specification activity. Users sometimes try to end- run the requirements process and coax specific developers into implementing their favorite features. Marketers build a marketing case and insist later that their favorite features be added. Developers implement unrequired features on their own time or when the boss is looking the other way.
Visit our web design programs services for an affordable and reliable webhost to suit all your needs.

Chapter 14: Feature-Set Control gROSS-REFERENCE For more on versioned development, see “Define Families of Programs” in Section 19.1; Chapter 20, “Evolutionary Delivery”; and Chapter 36, “Staged Delivery.” As with minimal specification, the ultimate success of this practice depends on follow-through. If you begin with 100 requirements and the requirements- scrubbing activity pares that number down to 70, you might well be able to complete the project with 70 percent of the original effort. But if you pare the list down to 70 only to reinstate the deleted requirements later, the project will likely cost more than it would have if you had retained the entire 100 requirements the whole time. Figure 14-3. Smaller projects take less time to build. Versioned Development An alternative to eliminating requirements altogether is eliminating them from the current version. You can plan out a set of requirements for a robust, complete, ideal project but then implement the project in pieces. Put in any hooks you’ll need to support the later pieces, but don’t implement the pieces themselves. The development practices of evolutionary delivery and staged deliver)^ can help in this area. The inevitable effect of using these practices is that by the time you finish version 1 and begin work on version 2, you scrap some of the features you had originally planned to have in the version 2 and add others. When that
If you are looking for cheap and quality webhost to host and run your website check Jboss Web Hosting services.

CROSS-REFERENCE For more on flexible development approaches, see Chapter 7, “Llfecycle Planning,” and Chapter 19, “Designing for Change.” 14.1 Early Project: Feature-Set Reduction Keep the spec to a minimum. With any of these approaches, you’ll need to make it clear that one of the objectives is to specify only the minimum detail necessary. For items that users might or might not care about, the default option should be to leave further specification to the developers. When in doubt, leave it out! Capture the important requirements. Although you should try not to capture requirements that the users don’t care about, you must be careful to capture all of the requirements that they do care about. Doing a good minimal spec requires a special sensitivity to what users really care about. Use flexibledevelopment approaches. Use development approaches that allow mistakes to be corrected. With a minimal-spec approach, more mistakes will occur than with a traditional-spec approach. The use of flexible development approaches is a means of hedging your bet that you can save more time than you waste. Involve key users. Find people who understand the business need or organizational need for the software, and involve them in product specification and development. This helps to avoid the problem of omitted requirements. Focus on graphically oriented documentation. Graphics in the form of diagrams, sample outputs, and live prototypes tend to be easier to create than written specifications and more meaningful to users. For the graphically oriented parts of your system, focus your documentation efforts on creating graphically oriented materials. Requirements Scrubbing Entirely removing (”scrubbing”) a feature from a product is one of the most powerful ways to shorten a software schedule because you remove every ounce of effort associated with that feature: specification, design, testing, documentation everything. The earlier in the project you remove a feature, the more time you save. Requirements scrubbing is less risk)’ than minimal specification. Because it reduces the size and complexity of the product, it also reduces the overall risk level of the project. (See Figure 14-3 on the next page.) The idea behind requirements scrubbing is simple: After you create a product specification, go over the specification with a fine-tooth comb and with the following aims: Eliminate all requirements that are not absolutely necessary. Simplify all requirements that are more complicated than necessary. Substitute cheaper options for all requirements that have cheaper options.
Please visit our professional web hosting services to find out about cheap and reliable webhost service that will surely answer all your demands.

Chapter 14: Feature-Set Control CLASSIC MISTAKE CROSS-REFERENCE For more on the problem of setting too many goals at once, see “Goal Setting’ in Section 11.2 and the discussion of ‘’Unclear or Impossible Goals” in Section 14,2, later in this chapter. CROSS-REFERENCE For more on gold-plating, see Chapter 5, “Risk Management,” and Chapter 39, “Timebox Development.” With minimal specification, you in effect have the developers do much of the specification themselves. When they specify the product, it becomes their product, and they will do whatever is needed to make their product a success. Opportunistic efficiency. With a minimal spec, developers are more free to design and implement the software in the most expeditious way possible. When every detail is spelled out in advance, they are more constrained. Less wasted effort. Developers often expend effort trying to get users or customers to specify things they don’t really care about. A minimal spec avoids that wasted effort and in general avoids the bureaucratic problems associated with traditional specification efforts. Shorter requirements phase. A minimal spec takes less time to create than a traditional spec; you can save time during the requirements definition itself. Risks of minimal specifications The minimal-spec approach is also subject to several risks. Omission of key requirements. When you create a minimal spec, you leave out everything that you’re sure the customer doesn’t care about, but you risk leaving out tilings that the customer does care about. The minimal spec is a gamble. You bet that the time you would waste specifying unnecessary details in a traditional, detailed spec would outweigh the time you will waste by overlooking requirements and making more expensive changes later with a minimal spec. If you lose the bet, you deliver the software later than you would have if you had used traditional methods. Unclear or impossible goals. Crystal-clear goals are essential to the success of a minimal-spec approach. The approach works because it allows developers to use ambiguities in the spec to their advantage. Goals tell them in which direction to resolve those ambiguities. Do they resolve them toward maximum usability, maximum “Wow!” factor, orminimum development time? If minimum development time is clearly the top priority, developers will resolve ambiguities to favor development speed. If the development-speed goal is not the clear top priority, developers might favor development speed or they might favor something else. The effect will not be the shortest possible development schedule. If you have a complex set of goals, you’ll be better off to create a traditional specification and spell out what you want in detail. Gold-plating. Minimal specifications increase the risk of developer gold- plating; it is a natural consequence of the ownership that they feel from being able to specify much of the product themselves. They want their product to be as good as possible, and their internal notions of product quality can take
Please visit our professional web hosting services to find out about cheap and reliable webhost service that will surely answer all your demands.