In software design it is primarily the development method and not the pattern and its pattern language that influences
the process of pattern selection and usage. As discussed in the concept Patterns, Alexander developed the concept of
generative pattern languages to guide a designer’s application of individual patterns to the entire design. In software
design however, as observed by Alexander [OOPSLA96] there is little evidence of using generative pattern languages.
For iterative development methods such as OpenUP, software patterns and pattern languages support the development
method through their ability to be applied incrementally or piecemeal growth and by providing extensible structures.
From an architectural perspective these two qualities allow software architecture to be designed and refactored
incrementally and so avoid the need for a so called "big up front design".
Piecemeal Growth
The term piecemeal growth as it applies to patterns, originates in Alexander's work and refers to a top down design
process in which a design starts from a high level structure that is embellished or refined through the implementation
of lower level patterns. For software development this corresponds to using hierarchies of architectural and design
patterns and idioms like those proposed by Buschmann et. al. [BUS96]. Using the idea of piecemeal growth an architect can start with one or more
architectural patterns to provide an architectural vision for the design and then progressively extend the design using
design patterns. For example, an interactive application may use the Model-View-Controller pattern as its architectural
vision then during implementation the Command pattern may be selected to implement the Controller component.
Extensibility
A key aspect of object oriented design patterns is their ability to support extension without causing the rewriting of
existing code. This feature allows a bottom up approach to the design process through code refactoring. When a problem
is encountered during coding such as duplicate code, the developer can weighed up various patterns and their tradeoffs
and select the appropriate solution in the context of the application.
references
[OOPSLA96] The Origins of Pattern Theory the Future of the Theory, And The Generation of a Living World. The 1996 ACM
Conference on Object-Oriented Programs, Systems, Languages and Applications (OOPSLA). See http://www.patternlanguage.com/archive/ieee/ieeetext.htm
|