Is OOP Really That Bad?

Sometimes I'm wondering if Object-Oriented Programming (OOP) is really as bad as I think, or if that is just selective perception. The term is widely used, but there is no consistent definition, so it's difficult to pinpoint exactly what people like or dislike about it. How can so many programmers not recognise that its core ideas are bad? And I'm not only talking about inheritance. Even some of the biggest OOP hardliners have acknowledged that this was a mistake. On top of that, it is hard to find qualified research on the topic, since it's basically impossible to conduct unbiased studies. To get to the bottom of it, I gathered a collection of quotes from highly respected programmers outside of the OOP bubble.

Edsger W. Dijkstra (1989) #

"Object-oriented programming is an exceptionally bad idea which could only have originated in California."

Years before Java came out, there were already voices against OOP. The aversion against it is clearly not a new phenomenon.

source: https://wiki.c2.com/?EwDijkstraQuotes

Joe Armstrong (2000) #

Objects bind functions and data structures together in indivisible units. I think this is a fundamental error since functions and data structures belong in totally different worlds.

The creator of Erlang was also not shy to share his dislike for OOP. He had some very good arguments which characteristics make OOP bad and why, and even an explanation for its popularity:

If a language technology is so bad that it creates a new industry to solve problems of its own making then it must be a good idea for the guys who want to make money.

source: https://www.cs.otago.ac.nz/staffpriv/ok/Joe-Hates-OO.htm

Paul Graham (2002) #

Object-oriented programming is popular in big companies, because it suits the way they write software. At big companies, software tends to be written by large (and frequently changing) teams of mediocre programmers. Object-oriented programming imposes a discipline on these programmers that prevents any one of them from doing too much damage. The price is that the resulting code is bloated with protocols and full of duplication. This is not too high a price for big companies, because their software is probably going to be bloated and full of duplication anyway.

A very high level approach, that could both explain why OOP is so popular, and why so many programmers don't realise it.

source: https://paulgraham.com/noop.html

Rob Pike (2004) #

object-oriented design is the roman numerals of computing.

Another very fitting description by the creator of Go. Obviously not only functional programmers despise OOP.

source: https://groups.google.com/g/comp.os.plan9/c/VUUznNK2t4Q/m/Ff_uWhnsbwAJ?pli=1

Linus Torvalds (2007) #

In other words, the only way to do good, efficient, and system-level and portable C++ ends up to limit yourself to all the things that are basically available in C. And limiting your project to C means that people don't screw that up, and also means that you get a lot of programmers that do actually understand low-level issues and don't screw things up with any idiotic "object model" crap.

The author of Linux and Git mainly focuses on performance. But there is also a devastating statement about maintainability in his message:

They use "nice object-oriented libraries". They use "nice C++ abstractions". And quite frankly, as a result of all these design decisions that sound so appealing to some CS people, the end result is a horrible and unmaintainable mess.

source: https://lwn.net/Articles/249460/

Rich Hickey (2011) #

When we drop down to the algorithm level, I think OO can seriously thwart reuse. In particular, the use of objects to represent simple informational data is almost criminal in its generation of per-piece-of-information micro-languages, i.e. the class methods, versus far more powerful, declarative, and generic methods like relational algebra. Inventing a class with its own interface to hold a piece of information is like inventing a new language to write every short story. This is anti-reuse, and, I think, results in an explosion of code in typical OO applications.

Consequently, OOP should be a very bad choice for designing algorithms with reuse in mind. Maybe if you don't do that, you might not notice.

source: https://github.com/matthiasn/talk-transcripts/blob/master/Hickey_Rich/RichHickeyQandA.md

John Carmack (2012) #

Class methods that can’t be const are not pure by definition, because they mutate some or all of the potentially large set of state in the object. They are not thread safe, and the ability to incrementally poke and prod objects into unexpected states is indeed a significant source of bugs.

When you start thinking about running, say, all the characters in a game world in parallel, it starts sinking in that the object oriented approach of updating objects has some deep difficulties in parallel environments.

It is hard to find claims about OOP from the legendary game programmer. He wrote an article about Functional Programming though, which he seems to prefer. Accordingly, his biggest issue with OOP is shared mutable state and it's unsuitability for parallel processing.

source: http://sevangelatos.com/john-carmack-on/

Casey Muratori (2014) #

I was introduced to “object oriented programming” when I was 18, and it took me until I was about 24 to realize it was all a load of horseshit (and the realization was thanks in no small part to my taking a job with RAD Game Tools, which thankfully never bought into the whole OOP nightmare).

This sounds very familiar. I had exactly the same experience, even though it took me longer to realise. Coming out of university, OOP was ingrained in me, and I can very well imagine that many programmers never question it.

if good programmers don’t start posting about how to do good programming, we’ll never get out of this nasty place where everyone has to go through six years of writing horrible object-oriented programs before they realize they’re wasting their time

source: https://caseymuratori.com/blog_0015

Conclusion #

While the idea of OOP about message passing and isolated process state from Alan Kay might not have been bad, most modern implementations are. The original idea lives on in the Actor model.

The kind of OOP that favours shared mutable state and entanglement of data & functions really is that bad. It thrives by being passed from one generation of mediocre programmers to the next, fuelled by corporations making money of it. It is time to break the vicious cycle, talk more about the alternatives, and make sure nobody thinks that they have to use OOP anymore.