antipatterns.txt

google driven development
GDD
    e.g. javadoc

    You have to Google for documentation.

Architecture by Implication
    System that is developed without a
    documented architecture; often due to
    overconfidence based on recent success.

    Solution:
        Define architecture in terms of
        multiple viewpoints corresponding to
        system stakeholders.

Autogenerated Stovepipe
    Automatic generation of interfaces for
    distributed, large-scale systems from fine
    grain header files.

    Solution:
        Separation of the architecture-level
        framework design from the subsystem-
        specific design is essential to manage
        complexity.

Cover Your Assets
    Document driven software processes often
    employ authors who list alternatives
    instead of making decisions.

    Solution:
        Establish clear purposes and
        guidelines for documentation tasks;
        inspect the results for the value of
        documented decisions.

Design by Committee
    Committee designs are overly complex and
    lack a common architectural vision.

    Solution:
        Proper facilitation and software
        development roles can lead to much
        more effective committee-based
        processes.

Intellectual Violence
    People sometimes use obscure references to
    esoteric papers, theories, and standards
    for intimidation or short-term gain.

    Solution:
        Individuals and the organization
        should encourage and practice mutual
        education and mentoring.

Jumble
    Interface designs are an un-factored
    mixture of horizontal and vertical
    elements, leads to frequent interface
    changes, lack of reusability.

    Solution:
        Partition architectural designs with
        respect to horizontal, vertical, and
        metadata elements.

Reinvent the Wheel
    Legacy systems with overlapping
    functionality that don't interoperate.
    
    Every system built in isolation.

    Solution:
        Use architecture mining and "best of
        breed" generalization to define a
        common interface, then object wrapping
        to integrate.

Spaghetti Code
    An ad hoc software structure makes it
    difficult to extend and optimize code.

    Solution:
        Frequent code refactoring can improve
        software structure, support software
        maintenance, and iterative
        development.

Stovepipe Enterprise
    Uncoordinated software architectures lead
    to lack of adaptability, reuse, and
    interoperability.

    Solution:
        Use enterprise architecture planning
        to coordinate system conventions,
        reuse, and interoperability.

Stovepipe System
    Ad hoc integration solutions and lack of
    abstraction lead to brittle, un-
    maintainable architectures

    Solution:
        Proper use of abstraction, subsystem
        facades, and metadata leads to
        adaptable systems.

Swiss Army Knife
    Over-design of interfaces leads to objects
    with numerous methods that try to
    anticipate every possible need -- leads to
    designs that are difficult to comprehend,
    utilize, and debug, as well as
    implementation dependencies.

    Solution:
        Defining a clear purpose for the
        component and properly abstracting the
        interface is essential to managing
        complexity.

The Grand Old Duke of York
    Four out of Five developers cannot define
    good abstractions; this leads to excess
    complexity.

    Solution:
        Project teams should have designated
        architects who are abstractionists,
        i.e.  possess the architecture
        instinct.

        This leads to vendor lock-in.
        
        Proprietary, product-dependent
        architectures do not manage complexity
        and lead to a loss of control of the
        architecture and maintenance costs.
        
        Providing an isolation layer between
        product-dependent interfaces and the
        majority of application software
        enables management of complexity and
        architecture.

Warm Bodies
    Large software project teams make for
    ineffective organizations and overruns.
    
    Heroic programmers are essential.

    Solution:
        Small projects (4 people in 4 months)
        are much more likely to produce
        software success.

Wolf Ticket
    A technology is assumed to have positive
    qualities due to its open systems
    packaging or claimed standards compliance.
    
    Few standards have test suites (< 6%) and
    few products are actually tested for
    conformance.

    Solution:
        Discover the real truth behind the
        claims.
        
        Question authority.
        
        Assume nothing.
        
        Shift the burden of proof to the
        marketing organization.
        
        Talk directly to the technical product
        experts and developers.