The Structural Patterns rule category contains patterns that show
various types of structural elements, including structural antipatterns.
| Pattern |
Purpose |
|---|
| Component Cyclic Dependency |
A Component Cyclic Dependency pattern is a structural antipattern
that consists of interdependent components. A cyclic dependency between components
is considered a major architectural flaw. Such a dependency makes the code
difficult to understand and maintain. More important, cyclic dependencies
compromise software testing, parallel development, and reuse. Large-scale
software with many cyclic dependencies is fragile and unstable. |
| Component Global Breakable |
A Component Global Breakable pattern is a structural antipattern
for a system component that is often affected when any other component is
changed. Except for high-level concrete implementations, global breakables
are undesirable because they indicate fragility and a lack of modularity in
the system. |
| Component Global Butterfly |
A Component Global Butterfly pattern is a structural pattern for
an object that has many global dependents. Changes to a global butterfly often
have a significant impact on the rest of the system. For this reason, a global
butterfly should only be either a basic system interface or a utility class. |
| Component Global Hub |
A Component Global Hub pattern is a structural antipattern for a
component that has many global dependencies and many global dependents. A
global hub is often affected when anything is changed, and it affects a significant
percentage of the system when it changes. Global hubs are undesirable because
they indicate fragility and lack of modularity in the system. |
| Component Local Breakable |
A Component Local Breakable pattern is a structural antipattern for
a component that has many immediate dependencies. Such a component carries
excessive responsibility and is usually identified by many long methods. Breakables
make the code difficult to understand, maintain, and reuse. |
| Component Local Butterfly |
A Component Local Butterfly pattern is a structural pattern for a
component that has many immediate dependents. Changes to a local butterfly
often have a significant immediate impact on the rest of the system. For this
reason, a local butterfly should only be either a basic system interface or
a utility class. |
| Component Local Hub |
A Component Local Hub pattern is a structural antipattern for a component
that has many immediate dependencies and many immediate dependents. Such a
component carries excessive responsibility and also serves as a utility or
commonly used component. Hubs make the code difficult to understand, maintain,
and reuse. Hubs also make the code fragile and unstable. |
| Package Cyclic Dependency |
A Package Cyclic Dependency pattern is a structural antipattern that
consists of interdependent packages. A cyclic dependency between packages
is considered a major architectural flaw. Such a dependency makes the code
difficult to understand and to maintain. More importantly, cyclic dependencies
undermine testability, parallel development, and reuse. Large-scale software
with many cyclic dependencies is fragile and unstable. |
| Package Global Breakable |
A Package Global Breakable pattern is a structural antipattern for
a package that has many global dependencies. Such a package carries excessive
responsibility and usually contains several components with many global dependencies. |
| Package Global Butterfly |
A Package Global Butterfly pattern is a structural pattern for a
package that has many global dependents. Changes to a global butterfly often
have a significant impact on the rest of the system. For this reason, a global
butterfly package should only consist of either basic system interfaces or
utility classes. |
| Package Global Hub |
A Package Global Hub pattern is a structural antipattern for a package
that has many immediate dependencies. Such a package carries globally excessive
responsibility and also serves as a utility or commonly used package. The
package usually contains many components that have several global dependencies
and dependents. Package Global Hubs break the reusability of modules and make
the code difficult to understand and maintain. |
| Package Local Breakable |
A Package Local Breakable pattern is a structural antipattern for
a package that has many immediate dependencies. Such a package carries excessive
responsibility. The package usually contains a large number of components
or several components with many immediate dependencies. A Package Local Breakable
makes the code difficult to understand, maintain, and reuse. |
| Package Local Butterfly |
A Package Local Butterfly pattern is a structural pattern for a package
that has many immediate dependents. Such a package serves as a utility or
commonly used package. |
| Package Local Hub |
A Package Local Hub pattern is a structural antipattern for a package
that has many immediate dependencies and dependents. Such a package carries
excessive responsibility and also serves as a utility or commonly used package.
The package usually contains many components that can have many immediate
dependencies. Hubs make the code difficult to understand, maintain, and reuse.
Hubs also make the code fragile and unstable. |