I found this quote in "The Joy of Clojure" on p. 32, but someone said the same thing to me over dinner last week and I've heard it other places as well:


  [A] downside to object-oriented programming is the tight
  coupling between function and data.


I understand why unnecessary coupling is bad in an application.  Also I'm comfortable saying that mutable state and inheritance should be avoided, even in Object-Oriented Programming.  But I fail to see why sticking functions on classes is inherently bad.

I mean, adding a function to a class seems like tagging a mail in Gmail, or sticking a file in a folder.  It's an organizational technique that helps you find it again.  You pick some criteria, then put like things together.  Before OOP, our programs were pretty much big bags of methods in files.  I mean, you have to put functions somewhere.  Why not organize them?

If this is a veiled attack on types, why don't they just say that restricting the type of input and output to a function is wrong?  I'm not sure whether I could agree with that, but at least I'm familiar with arguments pro and con type safety.  This sounds to me like a mostly separate concern.

Sure, sometimes people get it wrong and put functionality on the wrong class.  But compared to other mistakes, this seems like a very minor inconvenience.

So, Clojure has namespaces.  How is sticking a function on a class in OOP different from sticking a function in a namespace in Clojure and why is it so bad?  Remember, functions in a class don't necessarily operate just on members of that class.  Look at java.lang.StringBuilder - it operates on any reference type, or through auto-boxing, on any type at all.

P.S. This quote references a book which I have not read: Multiparadigm Programming in Leda: Timothy Budd, 1995.

In theory, loose function-data coupling makes it easier to add more functions to work on the same data.  The down side is it makes it more difficult to change the data structure itself, which is why in practice, well-designed functional code and well-designed OOP code have very similar levels of coupling.  

Take a directed acyclic graph (DAG) as an example data structure.  In functional programming, you still need some abstraction to avoid repeating yourself, so you're going to make a module with functions to add and delete nodes and edges, find nodes reachable from a given node, create a topological sorting, etc.  Those functions are effectively tightly coupled to the data, even though the compiler doesn't enforce it.  You can add a node the hard way, but why would you want to?  Cohesiveness within one module prevents tight coupling throughout the system.

Conversely on the OOP side, any functions other than the basic DAG operations are going to be done in separate "view" classes, with the DAG object passed in as a parameter. It's just as easy to add as many views as you want that operate on the DAG data, creating the same level of function-data decoupling as you would find in the functional program.  The compiler won't keep you from cramming everything into one class, but your colleagues will. 

Changing programming paradigms doesn't change best practices of abstraction, cohesion, and coupling, it just changes which practices the compiler helps you enforce.  In functional programming, when you want function-data coupling it's enforced by gentlemen's agreement rather than the compiler.  In OOP, the model-view separation is enforced by gentlemen's agreement rather than the compiler.
