Object-Oriented Programming (OOP) has dominated software development for decades. Languages like Java, C++, Python, and C# promote objects, classes, and inheritance as central design principles.
Yet some of the most influential figures in computing—notably Linus Torvalds and Richard Stallman—have voiced strong criticism of OOP. Their views challenge the assumption that object-oriented design is inherently superior.
This article explores their arguments and what developers can learn from them.
OOP became popular in the 1990s and early 2000s as software systems grew more complex. The core idea is simple: represent real-world entities as objects that contain both data and behavior.
Common OOP principles include:
In theory, these principles make large systems easier to manage and extend. In practice, critics argue that OOP often introduces unnecessary complexity.
Linus Torvalds, the creator of the Linux kernel and Git, has repeatedly criticized object-oriented programming—particularly the style used in C++.
Torvalds has argued that OOP tends to hide program behavior behind layers of abstraction.
In heavily object-oriented systems:
This can make debugging harder compared to straightforward procedural code.
“C++ is a horrible language.”
While often quoted for shock value, the deeper point was that features like inheritance, operator overloading, and implicit behavior can obscure what code actually does.
Another criticism is that OOP encourages overengineering. Developers may create complex class hierarchies, deep inheritance chains, and unnecessary abstractions.
Instead of writing simple functions, systems become frameworks of interacting objects.
Torvalds favors simpler designs—one reason the Linux kernel is written primarily in C rather than object-oriented languages.
Inheritance is one of the most criticized features of OOP.
Torvalds has argued that composition and modular design are generally safer than inheritance-heavy architectures.
Richard Stallman, founder of the Free Software Foundation and creator of the GNU Project, is less vocal about OOP specifically but has expressed skepticism about programming fashions.
Stallman has emphasized that programming paradigms are tools, not dogmas. The belief that OOP should dominate all programming tasks can lead developers to force object-oriented solutions where they do not fit.
In many cases:
Much of the early GNU ecosystem—including GCC and GNU Emacs—was written using simpler paradigms.
Stallman’s philosophy prioritizes transparency, hackability, and straightforward program structure. Heavy abstraction can sometimes conflict with these goals.
The concerns raised by Torvalds and Stallman echo a broader shift in the software industry.
Developers are increasingly exploring alternatives such as:
Meanwhile, many performance-critical systems use data-oriented design to reduce abstraction overhead.
Despite these criticisms, OOP is not inherently bad. It remains useful in many contexts, particularly:
Languages like Python and Java demonstrate that OOP can be productive when used carefully.
The criticism from Linus Torvalds and Richard Stallman highlights an important lesson:
Programming paradigms are tools, not religions.
Object-oriented programming can be powerful, but forcing everything into classes and inheritance can lead to unnecessary complexity.
The best developers choose the simplest approach that solves the problem—whether that means procedural code, functional techniques, or object-oriented design.
In the end, good software engineering is less about choosing the “right paradigm” and more about writing clear, maintainable code.