Formal definition for term “pure OO language”?

I can’t think of a better place among SO siblings to pose such a question. Originally I wanted to ask “Is python a pure OO language?” but considering troubles and some sort of discomfort people experience while trying to define the term I decided to start with obtaining a clear definition for the term itself.

It would be rather fair to start with correspondence by Dr. Alan Kay, who has coined the term (note the inspiration in biological analogy to cells or other living objects).

There are following ways to approach the task:

Give a comparative analysis by listing programming languages that can exhibit (or fail to do so) certain properties unique and sufficient to define the term (although Smalltalk, Scala, ~~Java~~, and so on – are possible examples but IMO this way seems neither really complete nor fruitful)
Give a formal definition (or close to it, e.g. in more academic or mathematical style).
Give a philosophical definition that would totally rely on semantical context of concrete language or a priori programming experience (there must be some chance of successful explanation by the community).

My current version: “If a certain programming (formal) language that can (grammatically) differentiate between operations and operands as well as infer about the type of each operand whether this type is an object (in sense of OOP) or not then we call such a language an OO-language as long as there is at least one type in this language which is an object. Finally, if all types of the language are also objects we define such language to be pure (strong) OO-language.”

Would appreciate any possible improvement of it. As you can see I just made the definition dependent on the term “object” (often fully referenced as class of objects).

[EDIT]

In addition, I use (luckily well understood) notion of a type as in typed languages. Data type programming or type oriented programing is not only a syntactical interpretation (of the program text, i.e. how to treat certain values of literals and data variables – something that evolves into type safety) but can be attributed to language grammar and studied in formal way (using mathematical logic) as so called type systems. Notice that requiring particular type system to have a so called universal type is one of the ways defining purity of OO language (there are ways to expand this semantically).

how to answer:

it helps if you specify a book or a reference that supports/explains your understanding of terminology and concepts (usually a good definition covers or references all depended concepts except elementary).
if possible indicate an indented category of your answer/definition if it is not clear otherwise (see above: 1 – by language example, 2 – mathematical logic, 3 – technical description and programming philosophy)
classification is important (and also because term pure-OO is included into term OO) while answering try to unmix elements of OO paradigm from other well known methodologies (and by no means confuse/overlap them, e.g. typically elements of modular programming can be covered/embodied with OO programming): try to distinguish OOP from (including or being a part of) Functional programming, Logical programming (especially strongly specialized ), Abstarct Data Types (ADT), Modular, Metaprogramming (generics and LISP’s macroexpansion-time), Contracts (e.g. Eiffel), Aspect-oriented (AO), (difference between declarative and functional classification as well as historical definitions of Dijkstra’s structured are clear)

on difficulty of giving a formal definition: surprisingly enough it is very easy to give a mathematical description of OOP in form of a certain logical (formal) system (most likely type based) and defining one concept after another. One can even try to do something more practical by applying that formalism to type safety checking or new language design aspects than merely abstract entertainment or exercise (also lookup formulation of OOP in Intuitionistic Type Theory, Dependent types, independently, in FOL formalisms as lambda calculus and just by using category theory). A main point here is that unsurprisingly such formulations IMO are strongly biased (flawed) by most likely initially incomplete understanding of OOP (in computer engineering) and end up being almost inaccessible afterwards (thus hardly contributing backwards to programming world – maybe except certain percentage finds applications back from formal world by being integrated into popular languages).

So yes, it is difficult to give exactly a “good” definition, not just definition. But I am positive of asking this here because of your experience and direct involvement, guys.

OO, according to Alan Kay is all about message passing, and that’s it. You will see that qualities such as polymorphism and encapsulation are actually derived from message passing.

Now that stance is in fact very extreme, because it basically means that only Smalltalk and languages alike would qualify.

I think you can define OO as building your system on entities, that fully encapsulate their state, and that are rendered exchangeable due to their inherent polymorphous qualities. One could thus argue a purely OO language ensures these two core qualities are always met. What renders OO languages “impure” would be mechanisms that allow the creation of constructs that do not meet these criteria, such as the possibilities to:

declare public fields
declare variables that can only hold instances of a specific class and its subclasses (i.e. variables should be typed against interfaces, which is what the biological objects communicate through in Kay’s anology), which is rendered even narrower if the class in question is final, as that leaves even less room for polymorphism
declare primitives

Then again, IMHO language purity is more a weakness than a strength. OO is not a silver bullet. No single paradigm is.

I would approach this by defining it as a language which uses OOP constructs and nothing else (in the same way that a pure FP language uses pure functions with immutable data and nothing else).

In particular:

Every entity that your program operates on is a first class Object – i.e. no primitives, no pointers, no arrays etc.
The only thing you can do with an object is call a (potentially polymorphic) method on it (== sending a message). No other operations exist.
All data is encapsulated – i.e. no public field access, you must go via methods on an object
If you have first class functions then they must also be objects – so you would need to do something like functionObject.call(param1,param2)
No global variables – if you want something like this you would need to use an object to represent the current global environment, e.g. environment.getValue("myThing") or put the variable in a class object

Note that this still leaves quite a few options open:

Class-based vs. prototype-based object models
How inheritance is implemented (if at all)
Whether you have single or multiple dispatch on methods
Whether your objects are statically or dynamically typed
The exact syntax used for method calls (e.g. you could have some syntactic sugar for getters / setters etc.)

The discussion about so-called OO languages has always been a bit on the brain-washed side. Ie:

“Someone has told me that language X is OO, so therefore language X equals OO then every language that lacks the features of language X cannot possibly be OO. And because I’m writing my code in language X, everything I do is OO.”

The term object-oriented design boils down to 3 things:

Modular design with autonomous objects that don’t know needless information about the rest of the program, aka as loose coupling as possible.
Encapsulation of data inside objects to prevent external access, both intentional and accidental.
Clearly specified dependencies between objects. To achieve loose coupling, but also to make the program easier to maintain and expand.

1) is pure program design, it can be achieved in any programming language. However, some languages have helpful features such as class/struct and private keywords.

2) is mainly program design, though cannot be fully achieved without language support, since you need language mechanisms like private/static to protect against accidental use.

3) is mainly program design. There are typically three different dependencies: “object X contains object Y”, “object X is a kind of Y” and “object X interacts with object Y”. There are plenty of language features to help with these dependencies: inheritance/polymorphism, abstract base classes and so on.

Now, if we look at the above we can see that you barely need any language features to write OO programs. The features just make it far easier.

The above goals cannot be achieved by using some muddy backwards-logic: just because you use the class keyword, your program does not automatically get a modular design. Just because you use inheritance, it doesn’t automatically mean that your object dependencies make sense. A language with OO features would still allow things like class TheWholeBloodyProgram or “Animal inherits Cat”.

Sadly, the topic of good object-oriented program design is rarely mentioned in these kind of discussions. Brainwashed programmers only look at the syntax and yap things like for example “C++ has primitive data types so your C++ program isn’t OO”, then they go off to write a downright horrible program in their own favourite language, without using any hint of program design what-so-ever.

To answer the question: very few, if any languages have support for proper OO program design. To find out which languages that has certain OO-related features is irrelevant as long as the programmer doesn’t know what object-oriented design means. A programmer claiming that certain languages are object-oriented has most likely not grasped the concept of OO as whole. Ask the would-be OO programmer how they design OO programs. If the first thing they do is to start yelling language keywords, then you can safely assume they don’t know OO design.

Perhaps there exists some fancy high-level UML-ish tool far above the raw source code, which enforces the programmer to only write programs with good object-oriented design, but I doubt it. The best design tools for OO programming is most likely still the human brain and common sense.

No, there is no formal or even useful definition, and there never will be. To some people, OOP means “Universal base class” and “Must use reference semantics, best with a garbage collector”- and you can even get quibbles about syntax, one of the least relevant things ever invented.

Ultimately, first, you have to answer the question “What is an object?”. The more narrow-minded will insist on inheriting from some pointless universal base class and needlessly being allocated on a garbage collector to qualify. But I prefer a much more useful definition. The purpose of OOP is to have some data, and some functions you can call on that data. So

An object holds some state and offers some functions on that state.

In this case, even int qualifies. After all, when you write template code in C++ which can accept either primitives or objects, then it becomes difficult to argue that primitives are different in any substantial way. There’s nothing meaningfully different about Vector v1, v2; v1 + v2; instead of int v1, v2; v1 + v2; (except the crappy initialization semantics, one must admit). Also, this permits lambdas and such things to be objects, as they hold state- their captures- and offer a function on that state, to call the lambda.

Fortunately, we can also classify pointers to free functions as objects, since they both hold state (an address) and a function on that state (to call it). So a free function should be allowed- even if you were to say that all free functions are in fact global function pointers.

You can think of it by negative example. Java is not a pure object oriented language because there are also primitive types that are not objects. These are integers, doubles, arrays and so on. In a pure object language, the semantics of objects are available for everything.

There’s also the question of how much of the language is closed to modification, even within the object framework. In java you can’t define new subclasses for some classes, such as
String or Class.

Which languages are pure? The only candidate that comes to mind is smalltalk.

Filed under: softwareengineering - @ 05:54

Thẻ: object-oriented, terminology

Thiết kế website giá rẻ

Danh mục

Formal definition for term “pure OO language”?