A NAND logic gate. Computer circuits are set up to only care about the input and output of these constructs, and don't get involved in the inner workings

Abstraction also applies to digital technology. A common structure inside computers is a set of transistors set up to process two binary inputs and create an output based on the binary value of each input. We call this thing “logic gate.” We can talk about logic gates without talking about what they’re made out of. We talk this way when what is inside doesn’t matter.

Computers are like us

Computers make abstractions the same way we do. A binary adding circuit has no interaction with the transistors inside a logic gate. It knows inputs and outputs only. An adding circuit would only be affected by changes within the logic gate if those changes altered the way that inputs and outputs resolved. It is easy and extremely useful to set up a machine in a way that makes use of the concept of abstraction.

In most cases, it is worthwhile to also set up computer programs as sets of interacting abstractions. Lets stop for a moment: why is this the case? It has to do with the limited capacity of human memory and mental processing capabilities. Back to the hardware: when computer scientists talk about logic gates, brilliant as they are, they do not have the mental resources to conceptualize the path of electricity through a logic gate every time they wish to talk about the interaction between logic gates. By assigning meaning, language eliminates redundancy. Abstractions make complex systems understandable to human beings.

$spot -> sit() !!!

Object orientation is a programming practice that brings computer language very close to human language. Human languages have evolved over millions of years, and represent very closely our ideal way of affecting our environment. If you own a dog, take a minute to imagine it sitting in front of you. Your goal is to make the dog sit down, then lie down. Its name is Spot. You’ve trained your dog to respond correctly to “Spot sit” and “Spot lie down.” You say, “Spot, sit.” He sits. “Spot, lie down.” He lies down.

“Good boy Spot!” Caesar Milan would be proud.

$ripple -> sit();

Object orientation (OO) is a straight-forward, dominant, command oriented approach to getting what you want from computers. In OO you would say (php style):

$spot->sit() and then $spot->lie_down()

Now that’s calm, assertive leadership! First of course, you have to define $spot as an instantiation of class dog, sort of like training him. Dogs are like computers in that they will do what you want if you command them directly in language that they understand.

But computers are much more tractable even than dogs. Software will do what you want even if you don’t use an object oriented demeanor. So why do things this way? Sometimes its just not practical. But the rule of thumb is to use object orientation if it eliminates enough redundancy to make up for the extra code spent defining the objects. And it doesn’t always do this.

Normal WordPress, for example, isn’t very object oriented. We don’t say $post->publish(), but rather something like wp_insert_post(array('title' => 'whatever')). This makes sense because WordPress posts don’t really do very much. They make more sense as arrays, because their only real value is their properties. WordPress posts are passive, not assertive. They are always accusative direct objects of functions, like wp_insert_post(), or functions that load data from the database and create a $post array to be further manipulated.

Verbs and nouns

The language around WordPress posts is heavily verb focused, very much like Latin. My Latin professor used to remind us that in Latin “the verb was the train that pulled the freight of the sentence.” In function-oriented code, all power to change the state of the software rests within the function, and variables and arrays are just the values required variously within. Functions are wonderful abstractions of sequential operations. An ancient Roman, or the Pope would “get” functions pretty quickly.

OO treats the noun as the engine of affect. Fundamentally, the difference between OO and not-OO is the difference between the passive and the active voice. $spot->sit() resolves to “Spot sits,” whereas sit($spot) resolves to “Spot is made to sit”, or maybe “sitting happens and Spot is the sitter.” In English, the active voice comes across as more direct and less verbose. In Latin, it doesn’t matter and in fact the passive voice is often preferred. Is this simply a difference of taste?

Transitivity

What does it mean for an application to be “object oriented?” Lets think about Buddypress as opposed to standard WordPress. Buddypress has constructs like “group,” “friend,” “group member,” “message,” and anything else you might find on sites like facebook.com and myspace.com. Many of these constructs have transitive relationships, meaning that they affect other objects by means of a verb. For example, messages and group members all reference a person. Here is the object oriented literal phrasing of one such transitive interaction:

“Person A prepares a message. The content is ‘hello,’ and the recipient is Person B. Then Person A sends the message.”

And its non object oriented phrasing:

“message sending, a process in which the sender is denoted by being the first of two nouns separated by the preposition “between,” and in which the content of the message is denoted by a preceding “regarding,” occurs between Person A and Person B regarding “hello.”

Functions have a fatal flaw – variables don’t have a “case” to describe what they do in a function. For example, the verb “message send” would be considered a dative verb, because it has takes a nominative (the sender), an accusative (the message) and an indirect object (the recipient). In Latin, these nouns are construed in their appropriate cases to signify this. But in a computer program, such abstractions don’t exist.

Object orientation disambiguates

Object oriented programming keeps things simple. Instead of trying to describe an entire process as happening in one function, objects provide a way to describe processes as “things doing things,” and changing their own properties as well as the properties of their direct and indirect objects. Object oriented code essentially self-documents, because variable values exist connected with their roles, not simply listed as parameters of a function. Take the following example from bp-messages.php:

With object orientation, you can signify variable roles inline. You can only do this with functions to a limited extent – and specifically not when you are passing two variables of the same type (like two people) as arguments. function send_message('p1', 'p2', 'hello') does not intrinsically signify a transitive direction. In the realm of spoken languages, English primarily uses word position and Latin primarily case endings to disambiguate these situations. Object orientation disambiguates by pairing each variable value with a property key the meaning of which signifies the value’s role in the application.