Logo
Color-Of-Code
  Home   All tags   Terms and Conditions

Anti-Patterns

December 27, 2018

Software Anti-Patterns

Taken from Wikipedia, personal adaptations and additions made, shortened to be used as a small reference card, links back to wikipedia kept for details.

See also Software Design Patterns.

Organizational anti-patternsDetect: bad general company wide behavior
Analysis paralysisDevoting disproportionate effort to the analysis phase of a project
Cash cowA profitable legacy product that often leads to complacency about new products
Design by committeeThe result of having many contributors to a design, but no unifying vision
Escalation of commitmentFailing to revoke a decision when it proves wrong
Management by perkeleAuthoritarian style of management with no tolerance for dissent
Moral hazardInsulating a decision-maker from the consequences of his or her decision
Mushroom managementKeeping employees uninformed and misinformed (kept in the dark and fed manure)
StovepipeA structure that supports mostly up-down flow of data but inhibits cross organizational communication
Vendor lock-inMaking a system excessively dependent on an externally supplied component
Project management anti-patternsDetect: What can run a project against the wall?
Death marchEveryone knows that the project is going to be a disaster – except the CEO. However, the truth remains hidden and the project is artificially kept alive until the Day Zero finally comes ("Big Bang"). Alternative definition: Employees are pressured to work late nights and weekends on a project with an unreasonable deadline
GroupthinkDuring groupthink, members of the group avoid promoting viewpoints outside the comfort zone of consensus thinking
Smoke and mirrorsDemonstrating how unimplemented functions will appear
Software bloatAllowing successive versions of a system to demand ever more resources
Analysis anti-patternsDetect: Analysis and reporting issues
Bystander apathyWhen a requirement or design decision is wrong, but the people who notice this do nothing because it affects a larger number of people
Software design anti-patternsDetect: bad patterns used in architecture
Abstraction inversionNot exposing implemented functionality required by users, so that they re-implement it using higher level functions
Ambiguous viewpointPresenting a model (usually OOAD) without specifying its viewpoint
Big ball of mudA system with no recognizable structure
Database-as-IPCUsing a database as the message queue for routine interprocess communication where a much more lightweight mechanism would be suitable
Gas factoryAn unnecessarily complex design
Gold platingContinuing to work on a task or project well past the point at which extra effort is adding value
Inner-platform effectA system so customizable as to become a poor replica of the software development platform
Input kludgeFailing to specify and implement handling of possibly invalid input
Interface bloatMaking an interface so powerful that it is extremely difficult to implement
Magic pushbuttonCoding implementation logic directly within interface code, without using abstraction
Race hazardFailing to see the consequence of different orders of events
Stovepipe systemA barely maintainable assemblage of ill-related components
Object-oriented design anti-patternsDetect: wrong implementation in detailed design
Anemic Domain ModelThe use of domain model without any business logic which is not OOP because each object should have both attributes and behaviors
BaseBeanInheriting functionality from a utility class rather than delegating to it
Call superRequiring subclasses to call a superclass's overridden method
Circle-ellipse problemSubtyping variable-types on the basis of value-subtypes
Circular dependencyIntroducing unnecessary direct or indirect mutual dependencies between objects or software modules
Constant interfaceUsing interfaces to define constants
God objectConcentrating too many functions in a single part of the design (class)
Object cesspoolReusing objects whose state does not conform to the (possibly implicit) contract for re-use
Object orgyFailing to properly encapsulate objects permitting unrestricted access to their internals
PoltergeistsObjects whose sole purpose is to pass information to another object
Sequential couplingA class that requires its methods to be called in a particular order
Yo-yo problemA structure (e.g., of inheritance) that is hard to understand due to excessive fragmentation
Programming anti-patternsDetect: Bad low-level coding practices
Accidental complexityIntroducing unnecessary complexity into a solution
Action at a distanceUnexpected interaction between widely separated parts of a system
Blind faithLack of checking of (a) the correctness of a bug fix or (b) the result of a subroutine
Boat anchorRetaining a part of a system that no longer has any use
Busy spinConsuming CPU while waiting for something to happen, usually by repeated checking instead of messaging
Caching failureForgetting to reset an error flag when an error has been corrected
Cargo cult programmingUsing patterns and methods without understanding why
Coding by exceptionAdding new code to handle each special case as it is recognized
Error hidingCatching an error message before it can be shown to the user and either showing nothing or showing a meaningless message
Expection handling(a portmanteau of expect and exception) Using a language's error handling system to implement normal program logic
Hard codeEmbedding assumptions about the environment of a system in its implementation
Lava flowRetaining undesirable (redundant or low-quality) code because removing it is too expensive or has unpredictable consequences
Loop-switch sequenceEncoding a set of sequential steps using a loop over a switch statement
Magic numbersIncluding unexplained numbers in algorithms
Magic stringsIncluding literal strings in code, for comparisons, as event types etc.
Soft codeStoring business logic in configuration files rather than source code
Spaghetti codeSystems whose structure is barely comprehensible, especially because of misuse of code structures
Methodological anti-patternsDetect: Bad coding behaviour
Copy and paste programmingCopying (and modifying) existing code rather than creating generic solutions
Golden hammerAssuming that a favorite solution is universally applicable (See: Silver Bullet)
Improbability factorAssuming that it is improbable that a known error will occur
Premature optimizationCoding early-on for perceived efficiency, sacrificing good design, maintainability, and sometimes even real-world efficiency
Programming by permutation (or "programming by accident")Trying to approach a solution by successively modifying the code to see if it works
Reinventing the wheelFailing to adopt an existing, adequate solution
Silver bulletAssuming that a favorite technical solution can solve a larger process or problem
Tester Driven DevelopmentSoftware projects in which new requirements are specified in bug reports
Configuration management anti-patternsDetect: Bad relationship between components
Dependency hellProblems with versions of required products
DLL hellInadequate management of dynamic-link libraries (DLLs), specifically on Microsoft Windows
Extension conflictProblems with different extensions to pre-Mac OS X versions of the Mac OS attempting to patch the same parts of the operating system
JAR hellOverutilization of the multiple JAR files, usually causing versioning and location problems because of misunderstanding of the Java class loading model
Branching & Merging anti-patternsDetect: Difficult integration situations
Merge Paranoia, PhobiaAvoiding merging at all cost, usually because of a fear of the consequences
Merge ManiaSpending too much time merging software assets instead of developing them
Big Bang Merge, Mega monster mergeDeferring branch merging to the end of the development effort and attempting to merge all branches simultaneously
Never-Ending, Runaway MergeContinuous merging activity because there is always more to merge
Never-Ending, Runaway BranchThe branch is used for purposes beyond the original one leading to a pot-pourri of development activities
Wrong-Way MergeMerging a software asset version with an earlier version
Branch Mania, Branch-a-holic, OverbranchingCreating many branches for no apparent reason
Cascading Branches, Continual CascadingBranching but never merging back to the main line
Mystery Branch, The Unknown BranchBranching for no apparent reason, unclear naming, what is this branch for?
Temporary Branches, Spaghetti or "Go To" BranchingBranching for changing reasons, so the branch becomes a permanent temporary workspace
Volatile Branches, Codeline PuddlingBranching with unstable software assets shared by other branches or merged into another branch
Development FreezeStopping all development activities while branching, merging, and building new base lines
Berlin Wall, Integration WallUsing branches to divide the development team members, instead of dividing the work they are performing