c# ean 13 check For details on reviews, see 7 21, Collaborative 8 Construction. in C#.NET

Generate EAN 13 in C#.NET For details on reviews, see 7 21, Collaborative 8 Construction.

Figure 24-1 Small changes tend to be more error prone than larger changes (Weinberg 1983).

Programmers treat small changes casually. They don t desk-check them, they don t have others review them, and they sometimes don t even run the code to verify that the fix works properly.

The moral is simple. Treat simple changes as if they were complicated. One organization that introduced reviews for one-line changes found that its error rate went from 55 percent before reviews to 2 percent afterward (Freedman and Weinberg 1982).

Adjust your approach depending on the risk level of the refactoring Some refactorings are riskier than others. A refactoring like Replace a magic number with a named constant is relatively risk free. Refactorings that involve class or routine interface changes, database schema changes, changes to boolean tests, among others, tend to be more risky. For easier refactorings, you might streamline your refactoring process to do more than one refactoring at a time and to simply retest, without going through an official review.

For riskier refactorings, err on the side of caution. Do the refactorings one at a time. Have someone else review the refactoring or use pair programming for that refactoring, in addition to the normal compiler checking and unit tests.

Refactoring is a powerful technique, but it isn t a panacea, and it is subject to a few specific kinds of abuse.

Do not partially write a feature with the intent of refactoring to get it complete later. John Manzo

Don t use refactoring as a cover for code and fix The worst problem with refactoring is how it s misused. Programmers will sometimes say they re refactoring, when all they re really doing is tweaking the code, hoping to find a way to make it work. Refactoring refers to changes in working code that do not affect the program s behavior. Programmers who are tweaking broken code aren t refactoring; they re hacking. Avoid refactoring instead of rewriting Sometimes code doesn t need small changes it needs to be tossed out so you can start over. If you find yourself in a major refactoring session, ask if you should just be redesigning and reimplementing that section of code from the ground up instead.

The number of refactorings that would be beneficial to any specific program is essentially infinite. Refactoring is subject to the same law of diminishing returns as other programming activities, and the 80/20 rule applies. Spend your time on the 20 percent of the refactorings that provide 80 percent of the benefit. Here are some ways you can decide which refactorings are most important.

Refactor when you add a routine When you add a routine, check whether related routines are well organized. If not, refactor them. Refactor when you add a class Adding a class often brings issues with existing code to the fore. Use this time as an opportunity to refactor other classes that are closely related to the class you re adding. Refactor when you fix a defect Use the understanding you gain from fixing a bug to improve other code that might be prone to similar defects. Target error-prone modules Some modules are more error prone and brittle than others. Is there a section of code that you and everyone else on your team is afraid of That s probably an error prone module. Although most people s natural tendency is to avoid these challenging sections of code, targeting these sections for refactoring can be one of the more effective strategies (Jones 2000). Target high complexity modules Another approach is to focus on modules that have the highest complexity ratings. (See How to Measure Complexity in Section 19.6 for details on these metrics.) One classic study found that program quality improved dramatically when maintenance programmers focused their improvement efforts on the modules that had the highest complexity (Henry and Kafura 1984). In a maintenance environment, improve the parts you touch Code that is never modified doesn t need to be refactored. But when you do touch a section of code, be sure you leave it better than you found it. Define an interface between clean code and ugly code, and then move code across the interface The real world is often messier than you d like. The messiness might come from complicated business rules, hardware interfaces, or software interfaces. A common problem with geriatric systems is poorly written production code that must remain operational at all times.

An effective strategy for rejuvenating geriatric production systems is to designate some code as being in the messy real world, some code as being in an idealized new world, and some code as being the interface between the two. Figure 24-2 shows this idea graphically.