Skip to main content

Object Orientation Has Little to Do With “Objects”

I would like to declare that the word "Object" from "Object Orientated Programming" is damaging to any benefits. If this seems counter-intuitive, you should keep reading. This is a case where the title is harmful to the subject. Some people take things too far and imagine some requirement for the concept of an object, and forbid anything outside their definition. If we understand the real benefits of OOP, the inappropriateness of such object-enthusiasm becomes clear.

Do objects matter? Using a traffic simulation example, we'll say we have instances of a Car class. We add lots of methods, such as accelerate(speed_diff) and implement logic to stop the virtual car at a virtual red light. The non-OO alternative would be functions operating on data describing the state of the vehicle. When we add motorcycles, we non-OO version requires a new function to operate on the new kind of data; or, so we are told. We know the OO way of doing things is to create a Vehicle class and inherit it in both Car and Motorcycle. Somewhere along the way, we loose emphasis of the affect we actually benefit from.

We benefit from the interface of the "objects", not their virtue of being objects. Too often the consensus you here focuses on completely irrelevant aspects. Methods, classes, and objects are completely without value, if you do not employ the real benefits. The real benefit is that objects have shape, and multiple objects can have the same shape. This can manifest by a single function operating on both cars and motorcycles, for example. This is an obvious benefit to have accelerate() versus accelerate_car() and accelerate_motorcycle(). It does not matter that we pass something you can call an object to the function, but that we can pass different things which act similar enough to be handled uniformly. A very non-OO way would be a function which takes the current speed, and the acceleration, and returns the new speed. The caller would need to get the information, call the function, and change the speed of wherever it is stored. Here, the user is stuck depending on the internals, rather than the shape of the externals.

There are some common situations, where I hear complaints from new comers to the Python language. The misunderstanding of what OO means, and what a language should do, leads to misunderstandings of Python as a language.

Getting the length of an object is a great example. You find many Ruby and Java programmers confused or upset that we have no length property on all our objects with a length. The interesting part is the claim that this actually makes Python "less Object Oriented." The fact here is we have a perfectly acceptable model, with common interfaces in a variety of different Python objects. Duck typing is, perhaps, the ultimate goal of object orientation. Mappings, sequences, and iterations are other great examples of shape importance in Python.

Two top reasons are code reuse and design sanity. Centering on interfaces gives us both cheaply. We can reuse code, because we only care about how it acts, and not what it is. The design of the code is cleaner, because we can remove all reference and care related to what we are dealing with and treat it uniformly.

Comments

Fuzzyman said…
Whilst I agree that interfaces are one of the key benefits of OOP I don't think it is the only one.

Another benefit is the way that functionality is encapsulated in objects - allowing you to structure and think about your code in terms of interaction between objects.

Whilst those interaction happen *using* the interface, the *thinking* is in terms of the objects and the functionality wrapped up inside them - so OOP is definitely an 'appropriate' term, even if it can mislead the zealots...
Anonymous said…
Amen, in many ways static typing is the worst enemy of OOP, i don't think it is a coincidence that functional languages are statically typed either. While i'll agree that len() is a great reausable component of Python, i usually define a .lenght method /*or property*/ to any object I make that can benefit from it. I think most python objects *should* have one, and only use len() when there isn't one defined. It could also help if len() looked for .lenght() instead of .__len__() inside objects.
Jorge said…
I totally agree with the part that static typing sometimes gets in the middle of OOP. In fact several times while programming in Java I had wish I have a file-like-object approach, it's very frustrating to have all the methods present and yet having to get a interface or abstract class stuck in the middle.

In general I don't think Objects have little to do with OOP, it's more people overthinking stuff and putting too much constraints into something simple.

Object oriented programming is just trying to fit the real world into the computer, in the best way we can imagine it.
Alan said…
Why is there any advantage to x.length() over x.__len__() ?

Popular posts from this blog

Respect and Code Reviews

Code Reviews in a development team only function best, or possible at all, when everyone approaches them with respect. That’s something I’ve usually taken for granted because I’ve had the opportunity to work with amazing developers who shine not just in their technical skills but in their interpersonal skills on a team. That isn’t always the case, so I’m going to put into words something that often exists just in assumptions.
You have to respect your code. This is first only because the nature and intent of code reviews are to safeguard the quality of your code, so even having code reviews demonstrates a baseline of respect for that code. But, maybe not everyone on the team has the same level of respect or entered a team with existing review traditions that they aren’t acquainted with.
There can be culture shock when you enter a team that’s really heavy on code reviews, but also if you enter a team or interact with a colleague who doesn’t share that level of respect for the process or…

CARDIAC: The Cardboard Computer

I am just so excited about this.


CARDIAC. The Cardboard Computer. How cool is that? This piece of history is amazing and better than that: it is extremely accessible. This fantastic design was built in 1969 by David Hagelbarger at Bell Labs to explain what computers were to those who would otherwise have no exposure to them. Miraculously, the CARDIAC (CARDboard Interactive Aid to Computation) was able to actually function as a slow and rudimentary computer. 
One of the most fascinating aspects of this gem is that at the time of its publication the scope it was able to demonstrate was actually useful in explaining what a computer was. Could you imagine trying to explain computers today with anything close to the CARDIAC?

It had 100 memory locations and only ten instructions. The memory held signed 3-digit numbers (-999 through 999) and instructions could be encoded such that the first digit was the instruction and the second two digits were the address of memory to operate on. The only re…

How To Care If BSD, MIT, or GPL Licenses Are Used

The two recent posts about some individuals' choice of GPL versus others' preference for BSD and MIT style licensing has caused a lot of debate and response. I've seen everything as an interesting combination of very important topics being taken far too seriously and far too personally. All involved need to take a few steps back.

For the uninitiated and as a clarifier for the initiated, we're dealing with (basically) three categories of licensing when someone releases software (and/or its code):
Closed Source. Easiest to explain, because you just get nothing.GPL. If you get the software, you get the source code, you get to change it, and anything you combine it with must be under the same terms.MIT and BSD. If you get the software, you might get the source code, you get to change it, and you have no obligations about anything else you combine it with.The situation gets stickier when we look at those combinations and the transitions between them.

Use GPL code with Closed S…