Concept-oriented programming

From Wikipedia, the free encyclopedia

Not to be confused with concept programming.

Concept-oriented programming (CoP) is a programming paradigm which uses concepts as the main programming construct instead of classes as defined in OOP. A concept consists of one object class and one reference class. The object class is precisely what is meant by classes in OOP. Its instances, called objects, are passed-by-reference. What is new in CoP is the presence of the reference classes. Their instances, called references, are passed-by-value and are intended to indirectly represent objects. Thus concepts can be viewed a means for modelling references. The structure and functions of references define how objects are represented and accessed.

Variables in the concept-oriented program store custom references with arbitrary structure and functions defined in the reference classes of concepts. For example, let us consider the following fragment of code:

   Account account = getAccount();
   Person person = account.getOwner(); 
   Address address = person.getAddress();

If it were an OOP program then the variables account, person and address would contain primitive references provided by the compiler. In contrast, if it is a CoP program then these variables will contain references in the format provided by concepts Account, Person and Address, respectively. Notice that these objects may reside anywhere in the world because their references have a custom format and access procedures written by the programmer. Any access on such references is indirect and may involve rather complex intermediate operations executed behind the scenes.

Let us assume that concept Account used in the above code snippet to declare a type of variables is defined as follows:

   concept Account 
       reference { // Reference class 
           String accountNumber; // Indirect identifier 
           ... 
       }
       object { // Object class 
           double balance; 
           ... 
       }

In this case all variables having this concept as their type will store account number indirectly identifying this object rather than a primitive reference providing direct access. This account number is then passed-by-value to method parameters, stored-by-value in object fields and returned-by-value from methods. It is a virtual address of the account object and it is not known where this object actually resides. However, the programmer can work with such indirectly represented objects as if they were normal objects as used in OOP, i.e., CoP provides the illusion of direct instantaneous access for indirectly represented objects.

Each concept has a parent concept specified using inclusion relation which generalizes class inheritance. One consequence of having concept inclusion is that references get layered structure. Such references consisting of several segments are referred to as complex references. Thus variables in CoP contain hierarchical addresses of objects in a virtual address space. Developing the structure of such a space is one of the main concerns in the concept-oriented program design.

[edit] See also

[edit] References

[1] Savinov, A. "Concepts and their Use for Modelling Objects and References in Programming Languages", Technical Report, Institute of Mathematics and Computer Science, ASM, 2007.
[2] Savinov, A. "Concept as a Generalization of Class and Principles of the Concept-Oriented Programming" Computer Science Journal of Moldova 13(3), 292-335, 2005.