12.1 Causes of Antipatterns
Every program, big or small, contains
shortcuts, mistakes, and code that could have been thought out a
little better. What distinguishes an antipattern from these errors is
that, like a design pattern, it is repeated. When we explore the
causes of antipatterns, we don't need to look at why
they exist梬e need to look at why they persist and propagate.
The main reasons that antipatterns spread are:
Inexperienced developers are the major cause of antipatterns.
Obviously, newer developers are less likely to have come across these
common mistakes previously, and are less like to recognize when they
are making them. The danger of antipatterns is subtler when
experienced developers use new technology. This danger is especially
pronounced in J2EE technology, which evolves quickly, and in which
many of the standard tutorials and code generation tools are full of
antipatterns. To combat the problem, most organizations use training
as well as code reviews with senior developers. But the best defense
against antipatterns is to know your enemy: understanding and
recognizing antipatterns is the key to avoiding them.
Unreadable code is another fertile breeding
ground for antipatterns. Often, the existence of a well-known
antipattern will be hidden because readers have to spend all their
mental cycles trying to figure out what the code does, not why it
does it. Developers sometimes favor conciseness and optimization over
readability without taking into account the maintenance costs. Every
shortcut that saves a few keystrokes or a few bytes of memory should
be balanced against the costs in terms of developer hours and lost
business when a hard-to-find bug is discovered. Unreadable code is
best fought with consistency: publishing and enforcing code
guidelines, relentless commenting, and aggressive review.
Cut-and-paste development refers to
code that is taken from one place and pasted directly into another.
Teams sometimes assume that cut-and-paste is a form of reuse: because
the code has been used before, it is often considered more robust.
Unfortunately, cut-and-paste actually makes code less reliable, since
the pasted portion is used out of context. Even worse, bug changes
don't propagate: changes to cut-and-paste code must
be propagated manually. Cut-and-paste should only be necessary when
entire objects cannot be reused. If you find yourself copying a
particular piece of code, consider abstracting it and making it
available to many classes through inheritance or as part of a
separate utility class.
|