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

20.1 Using Evolutionary Delivery 20.1 Using Evolutionary Delivery To use Evolutionary Delivery, you need to have a fundamental idea of the kind of system you’re building at the outset of the project. As Figure 20-1 suggests, in the evolutionary-delivery approach, you start with a preliminary idea of what your customer wants, and you create a system architecture and core based on that. That architecture and core serve as the basis for further development. Design of Architecture and System Core Repeat this cycle until you run out of time, you run out of money, you complete the number of iterations planned, or the customer is satisfied. Figure 20-1. The Evolutionary Delivery lifecycle model draws from Staged Delivery’s control and Evolutionary Prototyping’s flexibility. You can tailor it to provide as much control or flexibility as you need. The architecture should anticipate as many of the possible directions the system could go as it can. The core should consist of lower-level system functions that are unlikely to change as a result of customer feedback. It’s fine to be uncertain about the details of what you will ultimately build on top of the core, but you should be confident in the core itself.
Looking for affordable and reliable webhost to host and run your business application? Then look no more and go to servlet web hosting services.

Chapter 20: Evolutionary Delivery CROSS-REFERENCE For details on these kinds of support for rapid development, see the introductions to Chapter 21, “Evolutionary Prototyping,” and Chapter 36, “Staged Delivery.” Some people go to the grocery store carrying a complete list of the groceries they’ll need for the week: “2 pounds of bananas, 3 pounds of apples, 1 bunch of carrots,” and so on. Other people go to the store with no list at all and buy whatever looks best when they get there: “These melons smell good. I’ll get a couple of those. These snow peas look fresh. I’ll put them together with some onions and water chestnuts and make a stir-fry. Oh, and these porterhouse steaks look terrific. I haven’t had a steak in a long time. I’ll get a couple of those for tomorrow.” Most people are somewhere in between. They take a list to the store, but they improvise to greater and lesser degrees when they get there. In the world of software lifecycle models, Staged Delivery is a lot like going to the store with a complete list. Evolutionary Prototyping is like going to the store with no list at all. Evolutionary Delivery is like starting with a list but improvising some as you go along. The Staged Delivery lifecycle model provides highly visible signs of progress to the customer and a high degree of control to management, but not much flexibility. Evolutionary Prototyping is nearly the opposite: like Staged Delivery, it provides highly visible signs of progress to the customer but unlike Staged Delivery, it provides a high degree of flexibility in responding to customer feedback and little control to management. Sometimes you want to combine the control of Staged Delivery with the flexibility of Evolutionary Prototyping. Evolutionary Delivery straddles the ground between those two lifecycle models and draws its advantages and disadvantages from whichever it leans toward the most. Evolutionary Delivery supports rapid development in several ways: It reduces the risk of delivering a product that the customer doesn’t want, avoiding time-consuming rework. For custom software, it makes progress visible by delivering software early and often. For shrink-wrap software, it supports more frequent product releases. It reduces estimation error by allowing for recalibration and reestimation after each evolutionary delivery. It reduces the risk of integration problems by integrating early and often whenever a delivery occurs. It improves morale because the project is seen as a success from the first time the product says, “Hello World” until the final version is ultimately delivered. As with other aspects of Evolutionary Delivery, the extent to which it supports rapid development in each of these ways depends on whether it leans more toward Staged Delivery or Evolutionary Prototyping.
If you are looking for affordable and reliable webhost to host and run your business application visit our ftp web hosting services.

Evolutionary Delivery Evolutionary Delivery is a lifecycie model that strikes a balance between Staged Delivery’s control and Evolutionary Prototyping’s flexibility. It provides its rapid-development benefit by delivering selected portions of the software earlier than would otherwise be possible, but it does not necessarily deliver the final software product any faster. It provides some ability to change product direction mid-course in response to customer requests. Evolutionary Delivery has been used successfully on in-house business software and shrink-wrap software. Used thoughtfully, it can lead to improved product quality, reduced code size, and more even distribution of development and testing resources. As with other lifecycie models, Evolutionary Delivery is a whole-project practice: if you want to use it, you need to start plan ning to use it early in the project. Efficacy Potential reduction from nominal schedule: Improvement in progress visibility: Effect on schedule risk: Good Excellent Decreased Risk Chance of first-time success: Chance of long-term success: Very Good Excellent Major Risks Feature creep Diminished project control Unrealistic schedule and budget expectations Inefficient use of development time by developers Major Interactions and Trade-Offs Draws from both Staged Delivery and Evolutionary Prototyping Success depends on use of designing for change 425
Please visit our professional web hosting services to find out about cheap and reliable webhost service that will surely answer all your demands.

Further Reading 19.6 Keys to Success in Using Designing for Change Here are the keys to success in designing for change: Identify the most likely changes. Use information hiding to insulate the system from the effects of the most likely changes. Define families of programs rather than considering only one program at a time. . Don’t count on the mere use of an object-oriented programming language to do the design job automatically. Further Reading The three Parnas papers below are the seminal presentations of the ideas of information hiding and designing for change. They are still some of the best sources of information available on these ideas. They might be difficult to find in their original sources, but the 1972 and 1979 papers have been reproduced in Tutorial on Software Design Techniques (Freeman arid Wasserman 1983), and the 1972 paper has also been reproduced in Writings of the Revolution (Yourdon 1982). Parnas, David L. “On the Criteria to Be Used in Decomposing Systems into Modules,” Communications ofthe ACM, v. 5, no. 12, December 1972, 1053-58 (also in Yourdon 1979, Freeman and Wasserman 1983). Parnas, David L. “DesigningSoftware forEaseofExtension and Contraction,” IEEE Transactions on Software Engineering, v. SE-5, March 1979, 128-138 (also in Freeman and Wasserman 1983). Parnas, David Lorge, Paul C. Clements, and David M. Weiss. “The Modular Structure of Complex Systems,” IEEE Transactions on Software Engineering, March 1985, 259-266. McConnell, Steve. Code Complete. Redmond, Wash.: Microsoft Press, 1993. Section 6.1 of this book discusses information hiding, and Section 12.3 discusses the related topic of abstract data types. Chapter 30, “Software Evolution,” describes how to prepare for software changes at the implementation level.
From our experience, we are can tell you that you can find a reliable and cheap webhost service at Java Web Hosting services.

Chapter 19: Designing for Change CROSS-REFERENCE For another broad view of object-oriented technology, see “Identifying Silver Bullets” in Section 15.5. 19.3 19.4 19.5 Doing object-oriented design effectively is harder than people have made it out to be. As discussed in Section 15.5, it is an expert’s technology. David Parnas writes that object-oriented (O-O) programming has caught on slowly for the following reason: [O-O] has been tied to a variety of complex languages. Instead of teaching people that O-O is a type of design, and giving them design principles, people have been taught that O-O is the use of a particular tool. We can write good or bad programs with any tool. Unless we teach people how to design, the languages matter very little. The result is that people do bad designs with these languages and get very little value from them. (Parnas in Brooks 1995) To design for change, you must actually design. Focusing on areas that are likely to change, information hiding, and families of programs make up the strategic backbone of object-oriented design. If you don’t follow those design steps, you might as well be working in Fortran, plain old C, or assembler. Side Effects of Designing for Change Programs that are designed for change continue to yield benefits long after their initial construction. Capers Jones reports that programs that are well- structured and developed with high quality are nearly guaranteed to have long and useful service lives. Programs that are poorly structured and developed with low quality are nearly always taken out of service or become catastrophically expensive to maintain within 3 to 5 years (Jones 1994). Designing for Change’s Interactions with Other Practices The flexibility provided by Designing for Change is an important part of the support needed for incremental-development practices such as Evolutionary Delivery (Chapter 20) and Evolutionary Prototyping (Chapter 21). The change-oriented design practices also provide moderate support for Reuse (Chapter 33). The Bottom Line on Designing for Change The bottom line is that Designing for Change is a risk-reduction practice. If the system is stable, it doesn’t produce immediate schedule reductions, but it helps to prevent the massive schedule slips that can occur when unanticipated changes cause widespread ripple effects through the design and code.
Check Tomcat Web Hosting services for best quality webspace to host your web application.

CROSS-REFERENCE For more on defining minimal feature sets and on versionedrelease practices, see Chapter 20, “Evolutionary Delivery”; Chapter 36, “Staged Delivery”; and “Versioned Development” in Section 14.1. CROSS-REFERENCE For more comments on object-oriented programming, see “Identifying Silver Bullets” in Section 15.5. 19.2 Managing the Risks of Designing for Change family of programs or just a single program that you’d like to prepare for change. A good practice is first to identify a minimal subset offunctionality that might be of use to the end-user and then to define minimal increments beyond that. The minimal subset usually won’t be large enough to make up a program that anyone would want to use; it is useful for the purpose of preparing for change, but it usually isn’t worth building for its own sake. The increments you define beyond that should also be so small as to seem trivial. The point of keeping them small is to avoid creating components that perform more than one function. The smaller and sharper you make the components, the more adaptable to change the system will be. Designing minimal components that add minimal incremental functionality also leads to systems in which you can easily trim features when needed. Use Object-Oriented Design One of the outgrowths of information hiding and modularity has been object- oriented design. In object-oriented design, you divide a system into objects. Sometimes the objects model real-world entities; sometimes they model computer-science structures or more abstract entities. A study at NASA’s Software Engineering Laboratory found that object-oriented development practices increased reusability, reconfigurability, and productivity, and they reduced development schedules (Scholtz, et al. 1994). Use object-oriented design, but don’t expect it to be a cure-all. The success of object-oriented, design in a high-change environment depends on the same factors that information hiding does. You still need to identify the most likely sources of change, and you still need to hide those changes behind narrow interfaces that insulate the rest of the program from potential changes. 19.2 Managing the Risks of Designing for Change Using the best practice of Designing for Change poses no risks to the rest of the project. The main risk associated with Designing for Change is simply the risk of failing to use the practice to its full benefit. Overrelianceon languagesand picturesratherthan on design. The mere act of putting objects into classes does not create an object-oriented design, does CLASSIC MISTAKE not provide information hiding, and does not protect a program from changes. The mere act of drawing a module-hierarchy chart does not create a change-tolerant design. Good designs come from good design work, not from pictures of design.
Note: In case you are looking for affordable and reliable webhost to host and run your j2ee application check Vision J2ee Web Hosting services.

III Chapter 19: Designing for Change Define Families of Programs David Parnas pointed out as early as 1976 that the developer’s job had changed from designing individual programs to designing families of programs (Parnas 1976, 1979). In the 20 years since he wrote that, the developer’s job has shifted even more in that direction. Developers today use the same code base to produce programs for different languages, different platforms, and different customers. Figure 19-1 illustrates how this is done. Figure 19-1. Family of products. Since most products eventually turn into a family of products, most design efforts should concentrate on designing a family of programs instead of just one. In this environment, Parnas argues that a designer should try to anticipate the needs of the family of programs in developing the base product. The designer should anticipate lateral versions such as in-house releases, English, European, and Far-Eastern versions, and the designer should also anticipate follow-on versions. The designer should design the product so that the decisions that are least likely to change among versions are placed closest to the root of the tree. This holds true whether you’re consciously designing a -,
If you are looking for cheap and quality webhost to host and run your website check Jboss Web Hosting services.

FURTHER READING For details on all these practices, see Code Complete (McConnell 1993). 19.1 Using Designing for Change Now suppose that you further discover you need to change the type of the ID from an integer to a string. If you’ve spread variable declarations like int ID throughout your program, your use of theNewID() function won’t help. You’ll still have to go through your program and make dozens or hundreds of changes. In this case, the design decision to hide is the ID’s type. You could simply declare your IDs to be oflDTYPE a user-defined type that resolves to int rather than directly declaring them to be of type int. Once again, hiding a design decision makes a huge difference in the amount of code affected by a change. Develop aChange Plan For the areas that are likely to change, develop change plans. Change plans can prescribe the use of any of the following practices: Use abstract interfaces to modules rather than interfaces that expose the implementation details. Use named constants for data-structure sizes rather than hard-coded literals. Use late-binding strategies. Look up data-structure sizes in an external file or registry in the Windows environment. Allocate data structures dynamically based on those sizes. Use table-driven techniques in which the operation of the program changes based on the data in the table. Decide whether to store the data table inside the program (which will require recompilation to change) or outside the program in a data file, initialization file, Windows registry, or resource file. Use routines rather than duplicating lines of code even if it’s only one or two lines. Use simple routines that perform single, small functions. If you keep routines simple, they’ll be easier to use in ways you didn’t originally anticipate. Keep unrelated operations separate. Don’t combine unrelated operations into a single routine just because they seem too simple to put into separate routines. Separate code for general functionality from code for specialized functionality. Distinguish between code for use throughout your organization, for use in a specific application, and for use in a specific version of an application. These practices are all good software-engineering practices, which, among other things, help to support change.
Note: In case you are looking for affordable and reliable webhost to host and run your j2ee application check Vision J2ee Web Hosting services.

Chapter 19: Designing for Change CLASSIC MISTAKE In the 20th anniversary edition of The Mythical Man-Month, Fred Brooks concludes that his criticism of information hiding was one of the few shortcomings of the first edition of his book. “Parnas “was right, and I was wrong about information hiding,” he proclaims (Brooks 1995). To use information hiding, begin design by listing design decisions that are likely to change (as described above) or especially difficult design decisions. Then design each module to hide the effects of changes to one of those design decisions. Design the interface to the module to be insensitive to changes inside the module. That way, if the change occurs, it will affect only one module. The goal should be to create black boxes modules that have well-defined, narrow interfaces and that keep their implementation details to themselves. Suppose you have a program in which each object is supposed to have a unique ID stored in a member variable called ID. One design approach would be to use integers for the IDs and to store the highest ID assigned so far in a global variable called MaxID. Each place a new object is allocated, perhaps in each object’s constructor, you could simply use the statement ID = ++MaxID. (This is a C-language statement that increments the value of MaxID by 1 and assigns the new value to ZD.) That would guarantee a unique ID, and it would add the absolute minimum of code in each place an object is created. What could go wrong with that? A lot of things could go wrong. What if you want to reserve ranges of IDs for special purposes? What if you want to be able to reuse the IDs of objects that have been destroyed? What if you want to add an assertion that fires when you allocate more IDs than the maximum number you’ve anticipated? If you allocated IDs by spreading ID = ++MaxID statements throughout your program, you would have to change the code associated with every one of those statements. The way that new IDs are created is a design decision that you should hide. If you use the phrase ++MaxID throughout your program, you expose the information that the way a new ID is created is simply by incrementing MaxID. If, instead, you put the statement ID = NewID() throughout your program, you hide the information about how new IDs are created. Inside the NeivID() function you might still have just one line of code, return. (++MaxID) or its equivalent, but if you later decide to reserve certain ranges of IDs for special purposes, to reuse old IDs, or to add assertions, you couldmake those changeswithin theNewID() function itself without touching dozens or hundreds of ID =NeivID() statements. No matter how complicated the revisions inside NewID() might’become, they wouldn’t affect any other part of the program.
We recommend cheap and reliable webhost to host and run your web applications: Coldfusion Web Hosting services.

CROSS-REFERENCE For more on information hiding, see”Further Reading” at the end of the chapter. 19.1 Using Designing for Change change. Robert L. Glass has pointed out that one characteristic of great designers is that they are able to anticipate more kinds of possible change than average designers can (Glass 1994a). Here are some frequent sources of change: Hardware dependencies File formats Inputs and outputs Nonstandard language features Difficult design and implementation areas Global variables Implementations of specific data structures Implementations of abstract data types Business rules Sequences in which items will be processed Requirements that were barely excluded from the current version Requirements that were summarily excluded from the current version Features planned for the next version Identifying changes needs to be done at design time or earlier. Identifying possible requirements changes should be a part of identifying requirements. Use Information Hiding Once you have created your list of potential changes, isolate the design decisions related to each of those changes inside its own module. By “module” I am not necessarily referring to a single routine. A module in this context could be a routine or a collection of routines and data. It could be a “module” in Modula-2, a “class” in .C++, a “package” in Ada, a “unit” in Turbo, Pascal, or Delphi, and so on. The practice of hiding changeable design decisions inside their own modules is known as “information hiding,” which is one of the few theoretical techniques that has indisputably proven its usefulness in practice (Boehm 1987a). In the time since David Parnas first introduced the technique, large programs that use information hiding have been found to be easier to modify by a factor offour than programs that don’t (Korson and Vaishnavi 1986). Moreover, information hiding is part of the foundation of both structured design and object-oriented design. In structured design, the notion of black boxes comes from information hiding. In object-oriented design, information hiding gives rise to the notions of encapsulation and visibility.
We recommend high quality webhost to host and run your jsp application: christian web host services.