There is no Silver Bullet

Most developers love simplifications — they love the idea of that one tool that solves all of their problems. We have seen that in the late 90s and early 2000s, when object-oriented programming (OOP) was promoted as the one solution to all software problems. Today, however, the tide seems to have turned and functional programming (FP) is on the rise. OOP, on the other hand, seems to be considered an obsolescent paradigm:

• “Inheritance is the Base Class of Evil” (Sean Parent, 2013)
• “OOP is dead” (Stoyan Nicolov, 2018)
• “[Object-oriented programming] is not what the cool kids are doing in C++.” (Jon Kalb, 2019)
• “Eliminating Virtual Functions” (Jonathan Gopel, 2022)
• ”I believe that object-oriented programming and especially its theory is overestimated. … C++ always had templates, and now also has std::variant, which makes most of the use of inheritance unnecessary.” (Unknown Reviewer, 2023)

std::variant is indeed a fantastic solution: it’s functional, it’s simple, it’s value-based, and — perhaps most importantly — it’s fast. So it feels and sounds like a great replacement of virtual functions and object-oriented programming.

Unfortunately it is not. There is no silver bullet. There simply isn’t this one solution that works everywhere and every time. Truth is that neither OOP nor FP can solve all problems — we need both of them.

In this talk I’ll shed light on this antagonistic competition between OOP and FP. I’ll compare them by means of a practical example and show that both have their architectural strengths, but also weaknesses — along with many similarities.

I’ll also demonstrate that OOP has evolved: today, we prefer the value-based Type Erasure style to the classic GoF style. From an architectural point of view, the object-oriented Type Erasure is the antipode to the functional std::variant and I’ll show that only a wise combination leads to successful architectures.