During the 1990s, Object-Oriented Programming (OOP) became the dominant approach to building software. Languages such as Java and C++ were widely promoted as the future of programming, promising better organization, reusability, and scalability.
However, not everyone was convinced. Some of the most influential figures in computer science have expressed serious concerns about OOP and how it is often used in real-world software.
Among the most notable critics are Linus Torvalds, Richard Stallman, and Brian Kernighan. Each of them approaches the issue from a different perspective, but they share a common theme: simplicity matters.
Linus Torvalds, creator of the Linux kernel and the Git version control system, is well known for his direct opinions about software engineering.
Torvalds has often criticized heavy object-oriented designs, especially those found in large C++ projects.
His main concern is that OOP frequently introduces unnecessary complexity through:
In Torvalds' view, these features can make programs harder to debug and harder to maintain.
This philosophy helps explain why the Linux kernel is written primarily in the C programming language rather than an object-oriented language.
C encourages a more straightforward programming style where the flow of the program is easier to follow.
Richard Stallman, founder of the GNU Project and the Free Software Foundation, is less focused on criticizing OOP directly.
Instead, he warns about treating programming paradigms as universal solutions.
During the height of the OOP boom, many developers believed that every system should be built around objects and class hierarchies.
Stallman argues that this mindset can lead to poor design decisions. Programming techniques should be chosen based on the problem being solved rather than the popularity of a particular paradigm.
Many GNU tools were written using simple procedural approaches that prioritize transparency and flexibility.
For Stallman, the most important qualities of software are freedom, understandability, and the ability for programmers to modify it.
Brian Kernighan, co-author of the famous book "The C Programming Language", is known for promoting clarity and simplicity in code.
Unlike more vocal critics, Kernighan does not reject OOP entirely. Instead, he emphasizes the importance of controlling complexity.
One of his well-known ideas is that:
Controlling complexity is the essence of computer programming.
When object-oriented techniques are used excessively, they can actually increase complexity rather than reduce it.
Examples include:
Kernighan encourages programmers to write simple, readable code and to avoid clever designs that obscure the program's behavior.
Despite their criticisms, none of these programmers argue that object-oriented programming should never be used.
Instead, their message is that software design should focus on clarity and practicality rather than ideology.
OOP can be useful in many situations, particularly in large applications with complex data models.
However, forcing every program into an object-oriented structure can lead to unnecessary complexity.
Good programmers choose the simplest solution that works. Sometimes that means using objects. Other times it means writing a straightforward procedural program.
In the end, the goal of programming is not to follow trends but to build software that works well and is easy to maintain.