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

Michael Foord 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.
mae 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

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

Statement Functions

At a small suggestion in #python, I wrote up a simple module that allows the use of many python statements in places requiring statements. This post serves as the announcement and documentation. You can find the release here . The pattern is the statement's keyword appended with a single underscore, so the first, of course, is print_. The example writes 'some+text' to an IOString for a URL query string. This mostly follows what it seems the print function will be in py3k. print_("some", "text", outfile=query_iostring, sep="+", end="") An obvious second choice was to wrap if statements. They take a condition value, and expect a truth value or callback an an optional else value or callback. Values and callbacks are named if_true, cb_true, if_false, and cb_false. if_(raw_input("Continue?")=="Y", cb_true=play_game, cb_false=quit) Of course, often your else might be an error case, so raising an exception could be u

How To use Sphinx Autodoc on ReadTheDocs with a Django application

Sphinx is awesome for writing documentation. ReadTheDocs is awesome for hosting it. Autodocs are great for covering your entire API easily. Django is a great framework that makes my job easier. Between these four things is an interaction that only brought me pain, however. I'm here to help the next dev avoid this. Autodocs works by importing your modules and walking over the classes and functions to build documentation out of the existing docstrings. It can be used to generate complete API docs quickly and keep them in sync with the libraries existing docstrings, so you won't get conflicts between your docs and your code. Fantastic. This creates a problem when used with Django applications, where many things cannot be imported unless a valid settings module can be found. This can prevent a hurdle in some situations, and requires a little boilerplate to get working properly with Sphinx. It require a little extra to get working on ReadTheDocs. What makes this particularly h