A *(paradigm) of programming.

There's a craze about any new software using the *(term) "Object-Oriented". But if you ask people what it means to be "OO", most won't be able to tell anything, because it's only a _(buzzword).

The meaningful ideas that have to be isolated and distinguished behind this fad are that of having a _(unified) way to manipulate _(object)s, but few understand it even partially, and even fewer are those fully conscious of what it means.

Another buzzword associated to "OO" is _(inheritance), often incorrectly presented as the essence of "OO" design, whereas it is only a braindead special-case way of organizing objects, often done with a lot of confusion.

Typical confusion in "OO" approaches are between (constant) values and (variable) state-holders, between (semantical) objects and (meta-semantical) environments, between (specificational) abstraction level and (implementational) dispatch-time (run-time vs compile-time), etc. In a sane design, these concepts would be distinguished and made orthogonal; they would not even intervene at all at the same place in the semantics.

For instance, most "OO" languages (like _(Java), _(C++)) can't distinguish the notion of a constant, absolute, value, as soon as this value is not "atomic" in the hardware (a curious limitation for alleged "high-level" languages); all objects are then modifiable records, which leads to all kinds of unsafety, bugs, and contortions when manipulating putatively constant recursive structures.

Languages with single-dispatch (among which are _(C++) and _(Java) again) also confuse the objects being manipulated with the environment in which they are manipulated; they force the programmer to define the semantics of "an integer", or "a polynomial", whereas anyone with a little background in formal mathematics knows that an isolated integer or polynomial has no meaning; only the set of integers, or the set of polynomials, has meaning. More generally, isolated objects mean nothing, only structured sets of objects do; and these language don't allow to manipulate those sets, to describe their properties. Languages with multiple dispatch, such as _(CLOS) or _(Cecil), do a better job of not associating environments to objects.

Even with multiple dispatch, all the widespread OO languages have a unique global environment to dispatch (multi)methods according to objects' class. This means that there is only one fixed way of looking at objects, whereas mathematicians will also tell you how the interesting properties of structures lie in the infinity of ways to isomorphically reformulate them. The only way round this unicity of view is the explicit wrapping of objects into new classes; but most languages do not allow generic wrappers, and/or impose restrictions in the specification and implementation of wrapped objects. 

_(Kent M. Pitman) has written a great essay about object-orientation as a term, _("What's in a name? Uses and Abuses of Lisp Terminology"|http://www.nhplace.com/kent/PS/Name.html) within his set of articles, _(Parenthetically-Speaking).

For true OO languages, see _(CLOS), _(Beta), _(Dylan), _(Self), _(Smalltalk), _(Java), _(OCAML).

For languages with true OO extensions, see _(Lisp), _(Perl), _(Scheme), _(Forth).

For false OO languages, see _(Ada), _(C++), _(Visual BASIC), _(Simula).

<ul class="links">
<li>The great _(Cetus links| http://www.cetus-links.com/).
<li>Bob Hathaway's _(OO FAQ| http://www.cyberdyne-object-sys.com/oofaq2/).
<li>The _(FOOL workshop| http://www.cis.upenn.edu/~bcpierce/FOOL/) proceedings.
<li>_("Copying and Comparing: Problems and Solutions"| http://citeseer.nj.nec.com/grogono00copying.html), a paper dealing with the issue of identity and value semantics in the paradigm.
</ul>