Object Mentor Blog: Is the Supremacy of Object-Oriented Programming Over?

Is the Supremacy of Object-Oriented Programming Over?

Dean Wampler — Mon, 20 Apr 2009 21:45:00 -0500

I never expected to see this. When I started my career, Object-Oriented Programming (OOP) was going mainstream. For many problems, it was and still is a natural way to modularize an application. It grew to (mostly) rule the world. Now it seems that the supremacy of objects may be coming to an end, of sorts.

I say this because of recent trends in our industry and my hands-on experience with many enterprise and Internet applications, mostly at client sites. You might be thinking that I’m referring to the mainstream breakout of Functional Programming (FP), which is happening right now. The killer app for FP is concurrency. We’ve all heard that more and more applications must be concurrent these days (which doesn’t necessarily mean multithreaded). When we remove side effects from functions and disallow mutable variables, our concurrency issues largely go away. The success of the Actor model of concurrency, as used to great effect in Erlang, is one example of a functional-style approach. The rise of map-reduce computations is another example of a functional technique going mainstream. A related phenomenon is the emergence of key-value store databases, like BigTable and CouchDB, is a reaction to the overhead of SQL databases, when the performance cost of the Relational Model isn’t justified. These databases are typically managed with functional techniques, like map-reduce.

But actually, I’m thinking of something else. Hybrid languages like Scala, F#, and OCaml have demonstrated that OOP and FP can complement each other. In a given context, they let you use the idioms that make the most sense for your particular needs. For example, immutable “objects” and functional-style pattern matching is a killer combination.

What’s really got me thinking that objects are losing their supremacy is a very mundane problem. It’s a problem that isn’t new, but like concurrency, it just seems to grow worse and worse.

The problem is that there is never a stable, clear object model in applications any more. What constitutes a BankAccount or Customer or whatever is fluid. It changes with each iteration. It’s different from one subsystem to another even within the same iteration! I see a lot of misfit object models that try to be all things to all people, so they are bloated and the teams that own them can’t be agile. The other extreme is “balkanization”, where each subsystem has its own model. We tend to think the latter case is bad. However, is lean and mean, but non-standard, worse than bloated, yet standardized?

The fact is, for a lot of these applications, it’s just data. The ceremony of object wrappers doesn’t carry its weight. Just put the data in a hash map (or a list if you don’t need the bits “labeled”) and then process the collection with your iterate, map, and reduce functions. This may sound heretical, but how much Java code could you delete today if you replaced it with a stored procedure?

These alternatives won’t work for all situations, of course. Sometimes polymorphism carries its weight. Unfortunately, it’s too tempting to use objects as if more is always better, like cow bell.

So what would replace objects for supremacy? Well, my point is really that there is no one true way. We’ve led ourselves down the wrong path. Or, to be more precise, we followed a single, very good path, but we didn’t know when to take a different path.

Increasingly, the best, most nimble designs I see use objects with a light touch; shallow hierarchies, small objects that try to obey the Single Responsibility Principle, composition rather than inheritance, etc. Coupled with a liberal use of functional idioms (like iterate, map, and reduce), these designs strike the right balance between the protection of data hiding vs. openness for easy processing. By the way, you can build these designs in almost any of our popular languages. Some languages make this easier than others, of course.

Despite the hype, I think Domain-Specific Languages (DSLs) are also very important and worth mentioning in this context. (Language-Oriented Programming – LOP – generalizes these ideas). It’s true that people drink the DSL Kool-Aid and create a mess. However, when used appropriately, DSLs reduce a program to its essential complexity, while hiding and modularizing the accidental complexity of the implementation. When it becomes easy to write a user story in code, we won’t obsess as much over the details of a BankAccount as they change from one story to another. We will embrace more flexible data persistence models, too.

Back to OOP and FP, I see the potential for their combination to lead to a rebirth of the old vision of software components, but that’s a topic for another blog post.

"Is the Supremacy of Object-Oriented Programming Over?" by Tom

Sat, 27 Feb 2010 21:57:13 -0600

As a historical programmer and a new student. The first thing that bytes me about OOP is the GOBS of code needed to accomplish the same thing with FP. For example: object alarm clock, write a method to change the time, write a method to change the alarm, write a method to….. etc, etc, etc. Back in FP, I was taught AlarmTime=Time (JUST GET IT DONE ALREADY)!

"Is the Supremacy of Object-Oriented Programming Over?" by keyur patel

Fri, 19 Feb 2010 00:39:32 -0600

i don’t think so that OOP is out, it is here to stay

"Is the Supremacy of Object-Oriented Programming Over?" by Mens timberland boots shoes

Thu, 31 Dec 2009 23:21:36 -0600

Largest selection of discount Timberland Boots for sale, Saving a lot at our Timberland Outlet Store. We assure you of our Best Services at all times.

"Is the Supremacy of Object-Oriented Programming Over?" by mens belts

Thu, 31 Dec 2009 23:16:53 -0600

Buy mens belts with a price guarantee and top rated customer service. You can compare multiple mens belts styles and find exactly your size and width.

"Is the Supremacy of Object-Oriented Programming Over?" by gucci louis vuitton shoes

Tue, 15 Dec 2009 21:18:00 -0600

Welcome to Freshstyleshop, the hottest urban clothing site on the net! We offer great products from Gucci sneakers, prada sneakers, LV shoes, True Religion Jeans and many more! Our selection of products are always increasing for the fact that we have new items added weekly to our selection. All products on our site are already marked down 40-60% off retail price. Freshstyleshop also backs all its orders with a 110% satisfaction guarantee, making sure that our customers are left satisfied with the hottest products on the net.

"Is the Supremacy of Object-Oriented Programming Over?" by gucci louis vuitton shoes

Tue, 15 Dec 2009 20:33:00 -0600

"Is the Supremacy of Object-Oriented Programming Over?" by Daniel Jomphe

Mon, 20 Jul 2009 12:09:41 -0500

Very nice article, thank you.

Warning 1: Dean mentioned his favored usage of OO in a pretty controversial way; he could have brushed the truth in a more amenable way to strong OO proponents. In any case, with proper knowledge and experience, his way of putting it makes a lot of sense.

Warning 2: This article could mislead the reader into thinking that polymorphism is only available through object orientation.

That said, the fact that FP has access to much more powerful types of polymorphism than is ever possible to use in typical OO just makes this article’s conclusions even much more true!

Thanks again.

"Is the Supremacy of Object-Oriented Programming Over?" by Cheap Bowling Balls

Sat, 04 Jul 2009 12:48:22 -0500

Very interesting. I think we are entering a very interesting time when it comes to the evolution of programming languages. With increased computing power I believe the way we go about designing and coding software is on the verge of revolutionary changes.

"Is the Supremacy of Object-Oriented Programming Over?" by Baseball Bats For Sale

Sat, 04 Jul 2009 12:43:36 -0500

I think OOP in some form will be around for a long time. Although how it is leveraged may change considerably.

"Is the Supremacy of Object-Oriented Programming Over?" by Order Tamiflu online

Wed, 24 Jun 2009 08:46:11 -0500

are much more severe: diseases than epidemics. In Alaska, a state with a person that has Ordering Tamiflu

"Is the Supremacy of Object-Oriented Programming Over?" by Vladimir Kelman

Mon, 25 May 2009 18:37:01 -0500

... When I mentioned SOA I’m not necessary meant Web Services, but rather a broader approach of moving functionality, which doesn’t belong to a simple object, to “sevice” or “manager” layer. A good introductory example of it (using C# static manager classes) is shown in “N-Layered Web Applications with ASP.NET” articles by Imar Spaanjaars http://imar.spaanjaars.com/QuickDocId.aspx?quickdoc=476. When we implemented our application following Imar’s approach, we found that functional constructs (like using LINQ extension methods of Where(), Select() , etc. instead of loops and using lambda expressions instead of stupid object wrappers) greatly simplify service layer. Also, things like extension methods in C# / implicits and traits in Scala improve OOP, make it more flexible.

"Is the Supremacy of Object-Oriented Programming Over?" by Vladimir Kelman

Mon, 25 May 2009 14:08:08 -0500

@Dean, I think that SOA really helps to simplify overcomplicated OOP design. In short: leave to an object what really belong to an object, move complex interactions between objects, which are not cohesive to any single object to service layer. Udi Dahan gave an interesting talk on this matter on InfoQ: http://www.infoq.com/presentations/Making-Roles-Explicit-Udi-Dahan. There is another attempt called DCI architecture (http://www.artima.com/articles/dci_vision.html) and fiercely criticized by John Zaborsky (http://www.artima.com/forums/flat.jsp?forum=226&;thread=253008&start=0&msRange=100). While I mostly agree with his arguments on DCI, I strongly disagree with his OOP-above-all attitude. SOA really helps. And, of course, functional approach greatly simplify things.

"Is the Supremacy of Object-Oriented Programming Over?" by Vladimir Kelman

Mon, 25 May 2009 14:06:53 -0500

"Is the Supremacy of Object-Oriented Programming Over?" by John "Z-Bo" Zabroski

Sat, 16 May 2009 12:42:19 -0500

Object-Oriented Programming DOES NOT EQUAL Object-Oriented Analysis & Design.

Functional programming is an excellent technique for code implementation, as it is more amenable to program proof techniques, is easier to test (stateless, no side effects), and does not require code to be littered with locks (the mainstream imperative OOP languages solution for concurrency).

Objects in the large, functions in the small.

"Is the Supremacy of Object-Oriented Programming Over?" by Peter

Tue, 12 May 2009 19:59:46 -0500

Dean wrote: ”…just put the data in a map (or list) ... hash maps? Why do we have them in Java, etc. in the first place? ...”

I think it is very disturbing and surprising to see hash tables are being recommended on this site which is associated with the publisher of books about how to write Clean Code and applying SOLID principles.

Why we have hash maps ? Well, as long as we use them for internal private usage only (and of course without exposing a public getter to the mutable “private” hash table that would destroy the encapsulation) they can be useful for example to implement a table look up (i.e. as an alternative to if/switch statements), for example a parameterized factory method might return Command objects from a typed hashmap with a key lookup.

Regarding the comparison with HttpSession, I would say that one should make a distinction with domain/application specific code and the code that is intended for being used in all kind of applications. In other words, in your own application code you should use your own domain abstractions, but if you create an application framework (e.g. the servlet API with HttpSession) which is intended for all kind of domains then it is hard to avoid all usages of things that generally should be avoided such as using Object in method signatures (as in the method “Object HttpSession.getAttribute(String)” ).

Another thing worth mentioning, regarding making a distinction between domain/application code and generic code is the usage of reflection. The reasoning (about why it exists if we should not use it) is similar, i.e. reflection is hard to avoid for creating frameworks such as Hibernate that should support all kind of domain objects. Otherwise reflection should be avoided in runtime (but can be used in design time, for code generation) not because it is difficult to write reflection but difficult to maintain due to its worthless semantic.

Regarding sending around hash maps in PUBLIC method signatures, it is an awful anti-pattern that should never be considered as even remotely acceptable. I have seen a system where virtually all method signatures were very “generic” :-( and received one hashtable as input parameter and returned another hashtable. Within the methods, the hashtables were often passed on to other methods, which sometimes populated them with more values or even removed values, and of course you can never feel sure that you do not break any code in such a system (assuming you do not have great unit/integration test coverage for your semantic-less hashtables) i.e. you do not dare to change more than you really have to, and it is NOT refactoring-friendly.

It is not only difficult to change existing code when using hash tables, but you will aso get problems when you want to try to reuse (e.g. invoke) an existing method, since it is difficult to get the whole picture about what kind of parameters the hashtable need to contain in the invocation. If you look in the method, it is not enough but you also have to keep looking in the all other methods that are invoked from within the method… Typically, you have to debug the method to get a feeling of what kind of stuff you have to push into the hashtable.

Please also keep in mind that if you want your code base to be considered as being good, then you should not have to even look in the implementation code, and definitely you should not have to debug it to understand it.

The hash table oriented architecture should really be strongly discouraged as an ANTI-PATTERN (!) and certainly not recommended at this kind of site (objectmentor with Robert C Martin) with a good reputation.

/ Peter

"Is the Supremacy of Object-Oriented Programming Over?" by Peter

Tue, 12 May 2009 19:59:19 -0500

Dean wrote: ”...just put the data in a map (or list) ... hash maps? Why do we have them in Java, etc. in the first place? ...”

/ Peter

"Is the Supremacy of Object-Oriented Programming Over?" by Richard Lynch

Wed, 06 May 2009 09:44:29 -0500

I’m happy to say that I never drank the Kool-Aid :-)

Don’t get me wrong: There were many times when an OOP architecture made a lot of sense. There were also a lot of times when it was just plain the wrong technology.

Frankly, if you’re not taking advantage of inheritence in a significant way, you’d be just as well off with name-spaces as a full-blown OOP. And 95% of what I saw people using OOP for was nothing more than name-space separation.

I’d rather see a well-architected procedural solution that fits the problem than a bloated OOP solution that has been so mutilated over time that it “fits” only if you stand on your head and whistle Dixie.

PS Common Lisp is typed—Every datum has a very specific data-type. The variables are free to take on any value, as it should be. I happen to hate static-typed languages, personally. Too many pointless hoops.

"Is the Supremacy of Object-Oriented Programming Over?" by paul.morrison@rogers.com

Tue, 05 May 2009 12:49:51 -0500

Your comments are spot-on, and illustrate exactly why Flow-Based Programming (FBP) is garnering more and more interest – plus the fact that it offers a simple, consistent approach to developing applications for the new multi-core computers that everyone says are so difficult to program. Some time ago I wrote a comparison of FBP and OO, and I think they have held up – http://www.jpaulmorrison.com/fbp/oops.htm

"Is the Supremacy of Object-Oriented Programming Over?" by Y

Tue, 05 May 2009 00:59:15 -0500

Sounds like baiting for flames, links and whatever popularity you can get – and I must say this is a very succesful post if you look at it from the point of view of getting the word out

"Is the Supremacy of Object-Oriented Programming Over?" by Olly

Mon, 04 May 2009 20:09:36 -0500

Nice read, though I think you’re pretty biased. I wouldn’t think map-reduce is anywhere close to mainstream. Yes, you can read a lot about it, and it does make sense in a few cases, but it won’t replace relational databases, its a niche.

"Is the Supremacy of Object-Oriented Programming Over?" by Vladas Saulis

Mon, 27 Apr 2009 14:30:29 -0500

Good article. Personally, I never took OOP for serious. As I learned OO back in 1988, I thought it must be a very specific programming model, for a very specific usage (i.e for modelling REAL objects, like planets, space-crafts, orbits, etc…).

My favourite is a singleton concept within OOP… That looks like apopheosis for all OOP misconcept :)

How could anyone even think it will become a prevailing technology in the next 20 years!

"Is the Supremacy of Object-Oriented Programming Over?" by Vladas Saulis

Mon, 27 Apr 2009 14:28:10 -0500

My favourite is a singleton concept within OOP… That looks like apopheosis for all OOP misconcept :)

How could anyone even think it will become a prevailing technology in the next 20 years!

"Is the Supremacy of Object-Oriented Programming Over?" by E45

Sat, 25 Apr 2009 16:00:13 -0500

nice article

"Is the Supremacy of Object-Oriented Programming Over?" by Paul Beckford

Sat, 25 Apr 2009 10:57:42 -0500

“Supremacy”? – Hardly relevant for a technical debate. For supposedly rational intellectual people we suffer immensely from fashion and spin.

In the sense of being fashionable, then it’s true a particular interpretation of OO ideas have been supreme. If we go back to the Original OO research however that took place at Xerox Parc in the 1970’s and early 80’s – what has been spun and popularised as OO today is very different from what they had in mind.

I will call their ideas “Pure OO”. Pure OO had a brief commercial success with Smalltalk-80, but was largely killed off by the competition which had a ‘superior’ business model. It was difficult to justify paying £3K for Smalltalk licenses when Sun Microsystems chose to give away a VM based language for free that they claimed was OO too. So free Java put an end to pure OO.

Even before Java, there was a strong bias against using anything that didn’t derive from C/Unix. So C++ another hybrid OO language was championed as the ‘OO’ language of choice. All this has to do with politics and vendors protecting market share and has nothing to do with computer science.

On the computer science front, pure OO, based on late-binding and message sends has always built on functional ideas and encourages a declarative programming style. Lisp and Smalltalk have much in common. The best way to look at it is that a function can be an object too. So I see no or very little conflict between OO and functional programming.

The real issue is that pure OO has been viewed (rightly so) as a disruptive technology. The incumbent technology base, built on C and Unix have found ways to neutralise the potential disruptive effect and hold on to their market. As a consequence we have spent the last 20 years using curly bracket languages that are ‘OO’ in name only.

This is what prompted the famous Alan Kay quote:

“I coined the term OO and I can tell you I didn’t have C++ in mind..”.

And just to show he wasn’t just picking on C++:

“Java is the worst thing to happen to computer science since MSDOS…”

Pure OO is still in obscurity. Languages like Ruby and Python show what is possible with Pure OO ideas and late-binding, but they do not extend these ideas or take them even as far as Smalltalk did.

A new language called Newspeak is attempting to extend the concepts expressed in Smalltalk and later the Self Language and take them to their ultimate expression. Unfortunately Newspeak remains obscure and is currently struggling for funding :)

So from a computer science view point, I wouldn’t call Pure OO supreme at all. No, it’s still languishing in obscurity and we are still to discover what exactly it is trying to be.

To quote Alan Kay one more time:

“The computer revolution hasn’t happened yet…”.

Paul.

"Is the Supremacy of Object-Oriented Programming Over?" by Andrew Walker

Thu, 23 Apr 2009 19:55:34 -0500

I think Keith is right, supremacy is not the term I would use. I would even suggest that OO never went ‘mainstream’ in the first place. Just like agility, it is the label and not the intent of their early proponents that have become ‘mainstream’.

@Nirav – agree, people/social issues are the root cause of many perceived ‘failures’.

There is nothing wrong with OO per se, just in the interpretations of how to apply it. Corporate constraints and politics aside, its down to the individual programmer what languages, tools and techniques they are most comfortable with. Good people learn by practice and experience which tools are appropriate to use in a particular context and for my money, being able to make that choice is more valuable than a prescriptive approach.