3 Anti-pattern: excessive frameworks

Writing much of the code on top of complex frameworks instead of using layered design is an anti-pattern.

This is because:

  • Frameworks tend to increase the size of programs ("code bloat")
  • The complexity of framework APIs tends to increase overall development time due to the need to spend additional time learning to use the framework
  • The inversion of control means you give up control
  • Frameworks tend to have complex configuration
  • It's difficult to design a framework well
  • Frameworks tend to have lower performance, for example there is usually more dynamic polymorphism and less inlining
  • Code written for a framework is difficult to test (with automated tests)
  • Frameworks tend to be monolithic, in contrast to layered design which emphasises many independent modules
  • It's essentially an example of the more is less anti-pattern

Many software developers have an unfortunate tendency to write large applications directly on top of User Interface frameworks. A failure to separate User Interface code from the domain data structures and algorithms is an example of the excessive frameworks anti-pattern.

Similarly many software developers write applications on top of messaging frameworks.

Excessive use of dynamic polymorphism increases abstraction in a bad way, it hurts readability of the code. Rather than have function names which actually say what they do, there is a tendency to have generic names like OnMessage or OnKeyDown.

For example, it's probably a good idea for a function which might start a world war to have a descriptive name such as LaunchNuclearMissile rather that lurk in a function named OnButtonPressed.

The Single responsibility principle (SRP) suggests a message handler should only be responsible for receving the message and making a call on some other object which executes some function. This means the message handler has very little code, it's just an thin adapter. In that case most of the code is written in a layered manner, respects the SRP, and uses descriptive names for functions, rather than being written on top of some framework.