A term sometimes used in certain software engineering circles to refer to the excessive use of things like object-oriented programming, specifically its principle of abstraction, to create highly abstract, polymorphic, incomprehensible and unnecessarily complex systems within
software instead of keeping things simple.
This is usually practiced by "engineers" who value the "design" of
software more than actually delivering value
to the software's users and/or believe that writing software is akin to designing a
car or a building. Buildings, for example, cannot easily be torn down again if some part was constructed incorrectly or contains an error, whereas most software can.
While some
may argue that it's prudent to keep one's
code "clean" or "extendible" and whatnot, excessive abstraction can have the exact opposite effect: You get an unnecessarily complex mess that is extremely hard to untangle once you actually discover a use
case which it didn't account for. The result is a "building" that cannot easily be rebuilt -
said whiteboard masturbators will then argue, that "it should've just been designed
better in the first place" and that the "
model wasn't good enough" and will continue to draw UML diagrams that are of no use apart from impressing the sales department.
"
Maybe we should use a visitor pattern to separate this strategy from the
concrete adapter that is instantiated by our abstract factory so we can guarantee arbitrary observability throughout our proxied chain of responsibility."
"... listen, at this
point it's just whiteboard masturbation. Just keep it simple and write a function."